Spring笔记

Spring笔记 1、初步 *** 作： 第一步：配置pom.xml文件

 
        
            org.springframework
            spring-context
            5.3.13
        

        
            junit
            junit
            4.11
            test
        

    

第二步：编写dao层、service层

a、在com.liu.dao中编写一个SqlTest接口：

public interface SqlTest {
    public void getConn();

}

b、在com.liu.dao中有两个SqlTest接口的实现类：

1、MySqlTest

public class MySqlTest implements SqlTest{
    @Override
    public void getConn() {
        System.out.println("~~~~~MysqlLianjie");
    }
}

2、OracleTest

public class OracleTest implements SqlTest{
    @Override
    public void getConn() {
        System.out.println("~~~~Oracle获取链接");
    }
}

c、在com.liu.service中写一个SqlService接口：

public interface SqlService {
    public void getConn();
}

编写实现SqlService接口的实现类：

public class SqlServiceImpl implements SqlService{

    private SqlTest ssli;
    //为了能让spring代理
    public void setSsli(SqlTest ssl) {
        this.ssli = ssl;
    }
    @Override
    public void getConn() {
        ssli.getConn();
    }
}

第三步：编写spring的核心文件：bean.xml

注意：property中的属性：value：为基本类型赋值，ref：为引用（对象）

第四步：测试

public class TestSqll {
    @Test
    public void tesss(){
        //获取资源文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        //获取spring配置文件中的bean
        SqlServiceImpl serviceImpl =(SqlServiceImpl) context.getBean("getConn");
        serviceImpl.getConn();
    }
}

2、IOC创建对象的方式： IOC创建对象（构造器注入）的二种方式 第一种：无参构造

使用无参构造创建对象，默认选项

第二种有参构造：3种方式

1、通过下标赋值

*注意：*constructor-arg为有参构造是使用的

2、通过类的属性进行创建，不建议使用

*注：*type类型：需要写全称

3、通过参数名进行创建，推荐

总结：在配置文件加载时，容器中的管理的对象就已经初始化了！

3、spring配置： 1、别名

2、Bean的配置

	

注意：
id：bean的唯一标识符，也就是相当于对象名（eg：User us=new User()中的us）。
class：bean 对象所对应的全限定名：包名+类型（就是哪个类）。
name：bean 里的name是别名，且name可同时取多个别名

3、import

一般用于团队开发使用，可将多个配置文件，导入合并为一个。

假设项目有三个人开发，复制不同的类开发，不同的类需要注册在不同的bean中，

此时可使用 import将所有人的bean.xml合并为一个总的。

• eg：

  applicationContext.xml中

  使用的时候，直接使用 总的配置就可以了。

4、依赖注入： 依赖注入有三种 第一种：构造器注入

前面已经说过

第二种：Set方式注入【重点】

• 依赖注入：Set注入

  • 依赖：bean对象的创建依赖于容器！
  • 注入：bean对象中的所有属性，由容器来注入。

• 【环境搭建】：

  • 1、复杂类型：

    public class Address {
        private String address;
    		//getter setter方法
        }
    

  • 2、真是测试对象：

    public class Student {
        private String name;//姓名
        private Address address;//住址
        private String[] books;//书本
        private List hobbys;//爱好
        private Mapcard;//卡
        private Setgames;//游戏
        private String wife;//是否结婚
        private Properties info;//信息
    
        //getter setter方法
        }
    

  • 3、applicationContext.xml：

    
    
    
        
            
        
    
    
        
            
            
            
            
            
            
                
                    天路历程
                    神曲
                    忏悔录
                
            
            
            
                
                    慢跑
                    胡思
                    乱想
                
            
    
            
            
                
            
    
            
            
                
                    卡通农场
                    植物大战僵尸
                
            
    
            
            
            
            
            
                
            
    
            
            
                
                    3320010219
                    楠小弟
                    com.mysql.jdbc.Drive
                    127.0.0.1
                    root
                    123456
                
            
        
    
    

  • 4、测试类

    public class MyTest {
        @Test
        public void stuTest(){
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            Student stu = (Student) context.getBean("getStu");
           System.out.println(stu);
        }
    }
    
    

  • 5、结果

第三种：其他方式（拓展方式）

可使用P命令空间 和 c命令空间进行注入：

1、实体类User

public class User {
    private String name;
    private String sex;
    private int age;
    }

2、userBean.xml

3、测试类：

public class UserTest {
    @Test
    public void userTest(){
        ApplicationContext context = new ClassPathXmlApplicationContext("userBean.xml");
        User us = context.getBean("getUser", User.class);
        User us1 = context.getBean("getUser2", User.class);
        System.out.println("p标签的使用:"+us);
        System.out.println("c标签的使用:"+us1);
    }
}

4、结果：

p标签的使用:User{name='楠小弟', sex='楠', age=23}
c标签的使用:User{name='哈哈', sex='男', age=23}

注意：使用标签不要忘记导入依赖文件

xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"

5、Bean作用域： Bean作用域（Bean scopes） 1、单例模式（singleton）：

spring默认机制。

多个使用同一个对象，则引用的地址一样

2、原型模式：

每次从容器中get的时候，都会产生一个新对象。

3、request、session、application：

这些只能在web开发中使用到。

6、Bean自动装配：

• 自动装配是 spring 满足bean依赖一种方式！

• Spring会在上下文中自动寻找，并自动给bean装配属性！

• 在Spring中有三种装配的方式：

  • 1、在xml中显示的配置

  • 2、在Java中显示配置

  • 3、隐式的自动装配。【重要！！】

    • byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的 beanid！

    • byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean！

    • 1、一个人有猫、狗两动物

      public class Cat {
          public void shout(){
              System.out.println("喵喵喵~~~~叫");
          }
      }
      
      public class Dog {
          public void shout(){
              System.out.println("汪汪汪~~~~叫");
          }
      }
      
      
      public class Person {
          private Cat cat;
          private Dog dog;
          private String name;
          }
      

      2、PersonBean.xml

      3、测试类：

      public class PerTest {
          @Test
          public void perTest(){
              ApplicationContext context = new ClassPathXmlApplicationContext("PersonBean.xml");
              Person per = context.getBean("per", Person.class);
             per.getCat().shout();
             per.getDog().shout();
          }
      }
      

      4、结果：

      喵喵喵~~~~叫
      汪汪汪~~~~叫
      

    • 使用注解方式

      • 1、applicationContext.xml中添加：

    • 2、还是一人两动物：

    public class Cat {
        public void shout(){
            System.out.println("喵喵-----");
        }
    }
    
    
    public class Dog {
        public void shout(){
            System.out.println("汪汪----");
        }
    }
    
    public class Person {
        @Autowired
        private Cat cat;
        @Autowired
        private Dog dog;
    
        public Cat getCat() {
            return cat;
        }
    
        public Dog getDog() {
            return dog;
        }
    }
    

    • 3、spring配置文件
    • 4、测试类：

    public class TestAuto {
        @Test
        public void testAu(){
           ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            Person getPer = context.getBean("getPer", Person.class);
            getPer.getCat().shout();
            getPer.getDog().shout();
        }
    }
    

    • 5、结果：

    喵喵-----
    汪汪----
    

  • 小结：

    • @Autowried：

      直接在属性上使用即可！也可以在set方式上使用，保证IOC容器中（配置文件）中且是唯一出现

    • @Nullable：

      字段标记了此属性，说明这个字段可以为null且不会报错

    • @Autowired(required=false)：

      若定义了required=false，说明对象可以为null；反之不允许为空（默认值）

    • @Qualifier(value=“xxx”)：

      指定一个唯一的bean对象注入。就是说：当有好多个指向一个类，需要指定名字。需要和@Autowired一起使用。

    • @Resource注解：

      Java提供的注解

    • @Resource注解 和 @Autowired的区别：

      1、都是用来自动装配的，都可以放在属性字段上。
      2、@Autowired 通过byType的方式实现，且必须要求这个对象存在！
      3、@Resource默认通过byName的方式实现，若找不到名字，则通过byType实现，若都找不到则报错！
      4、执行顺序不同：@Autowired通过byType的方式实现。@Resource默认通过byName方式实现。
      

7、 使用注解开发： a、在applicationContext.xml中配置：

b、属性的注入：

@Component
public class User{
    public String name;
    @value("楠小弟")
    public void setName(String name){
        this.name=name;
    }
}

注意：

@Component（组件）相当于手动配置的：

@value（值）相当于手动配置的：

c、衍生的注解：

@Component有几个衍生注解，在Web开发中，会按照mvc三层架构分层！

• dao层 使用【@Repository】
• service层使用【@Service】
• controller层（servlet）使用【@Controller】
• 这四个注解功能都是一样的，都代表将某个类注册到Spring中，装配到Bean。

d、自动装配配置：

- @Autowired:自动装配通过类型、名字。
	若Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value="xxx")
- @Nullable：字段标记了这个注释，说明这个字段可以为null。
- @Resource：自动装配通过名字、类型。

e、作用域：

@Scope（“”）：可指定作用域的方式：单例、原型…

@Component
@Scope("prototype")
public class User{
    public String name;
    @value("楠小弟")
    public void setName(String name){
        this.name=name;
    }
}

f、小结：

• xml 与 注解 ：

  • **xml：**更加万能，适用于任何场合！维护简单方便
  • **注解：**不是自己类使用不了，维护相对复杂！

• xml 与 注解 最佳实践：

  • **xml：**用来管理bean；

  • **注解：**只负责完成属性的注入；

  • 在使用过程中，需注意一个问题：必须让注解生效，就需要开启注解的支持

g、使用Java配置spring：

springboot中会使用到此方法。

8、代理模式：

为什么要学习代理模式呢？因为这是SpringAOP的底层【SpringAOP 和 SpringMVC】。

代理模式的分类：

• 静态代理
• 动态代理

8.1、静态代理：

角色分析：

• 抽象角色：一般会使用接口或者抽象类来解决。
• 真实角色：被代理的角色。
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属 *** 作。
• 客户：访问代理对象的人！

代理模式的好处：

• 可使真实角色的 *** 作更加纯粹！不用去关注一些公共的业务。
• 公共也就是交给代理角色！实现了业务的分工！
• 公共业务发生扩展的时候，方便集中管理。

缺点：

• 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低。

8.2、动态代理：

• 动态代理 和 静态代理角色一样。

• 动态代理的代理类是动态生成的，不是我们直接写好的。

• 动态代理分为两大类：

  • ①基于接口的动态代理
    • JDK动态代理，【使用这个】
  • ②基于类的动态代理。
    • cglib
  • java字节码实现：javasist

  需要了解两个类：Proxy代理，InvocationHandler：调用处理程序

• 动态代理的好处：

  • 可使真实角色的 *** 作更加纯粹！不用去关注一些公共的业务。
  • 公共也就是交给代理角色！实现了业务的分工！
  • 公共业务发生扩展的时候，方便集中管理。
  • 一个动态代理类代理的是一个接口，一般就是对应的一类业务
  • 一个动态代理类可代理多个类，只要是实现了同一个接口即可。

9、AOP： 9.1、什么是AOP？

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

9.2、AOP在spring中的作用：

提供声明式事务；允许用户自定义切面

• 横切关注点：跨越应用程序多个模块的方法或功能。既是，与我们业务逻辑无关的，但我们需要关注的部分，就是横切关注点。如：日志，安全、缓存，事务等等…
• 切面（ASPECT）：横切关注点 被模块化的特殊对象。即，他是一个类。
• 通知（Advice）：切面必须要完成的工作。即，他是类中一个方法。
• 目标（Target）：被通知对象。
• 代理（Proxy）：向目标对象应用通知之后创建的对象。
• 切入点（PointCut）：切面通知 执行的“地点”的定义。
• 连接点（JointPoint）：与切入点匹配的执行点。

方式一：使用原生springAPI实现AOP【主要springAPI接口实现】：

• 1、service接口及实现类：

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}


public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加....");
    }

    @Override
    public void delete() {
        System.out.println("删除.....");
    }

    @Override
    public void update() {
        System.out.println("修改....");
    }

    @Override
    public void select() {
        System.out.println("查询....");
    }
}

• 2、编写log类在log包中：

public class BeforeLog implements MethodBeforeAdvice {
    @Override
    
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}


public class AfterLog implements AfterReturningAdvice {
    @Override
    //returnValue返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了："+method.getName()+"方法,返回结果为："+returnValue);
    }
}

• 3、applicationContext.xml配置文件：

• 4、测试类：

public class TestSix {
    @Test
    public void testLo(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理  代理的是接口:注意点
        UserService userService =(UserService) context.getBean("userService");
        userService.select();
    }
}

• 5、结果：

com.liu.service.UserServiceImpl的select被执行了
查询....
执行了：select方法,返回结果为：null

方式二：自定义实现AOP【主要是切面定义】（推荐）

• 1、编写service以及实现类，同上例子一样
• 2、编写diy类在diy包中

//自定义方法
public class Diy {
    public void before(){
        System.out.println("=======在前面执行=======");
    }
    public void after(){
        System.out.println("=====在后面执行====");
    }
}

• 3、配置文件

• 4、测试类，和上例子一样
• 5、结果：

=======在前面执行=======
增加....
=====在后面执行====

方式三：使用注解进行切面

1、编写AnnotationPointCut类

//标注这个类是一个切面
@Aspect
public class AnnotationPointCut {

    @Before("execution(* com.liu.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("===前面=====");
    }
    @After("execution(* com.liu.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("===后面-====");
    }

    //在环绕增强中，我们可给定一个参数，代表要获取处理切入的点
    @Around("execution(* com.liu.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        Signature signature = jp.getSignature();//获取签名
        System.out.println("signature签名为:"+signature);
        Object proceed = jp.proceed();//执行方法
        System.out.println("----环绕后----");
        System.out.println(proceed);
    }
}

*注意：*若不显示@Aspect提示：①查看是否有相关依赖②作用域是否没去掉

2、配置文件类：

3、测试类：和上例子一样。

4、结果：

环绕前
signature签名为:void com.liu.service.UserService.add()
===前面=====
增加....
===后面-====
----环绕后----
null

10、Mybatis-spring整合： 一：第一种方式 1、导入相应的pom配置文件：

 
        
        
            junit
            junit
            4.11
            test
        
        
        
            mysql
            mysql-connector-java
            5.1.47
        

        
        
            org.mybatis
            mybatis
            3.5.2
        

        
        
            org.springframework
            spring-context
            5.3.13
        

        
        
            org.springframework
            spring-jdbc
            5.3.13
        


        
        
            org.aspectj
            aspectjweaver
            1.9.7
        
        
        
            org.mybatis
            mybatis-spring
            2.0.6
        
    

注意：此处还需要配置 资源加载失败的文件：

 
    
        
            
                src/main/resources
                
                    ***.xml
                
                true
            
            
                src/main/java
                
                    ***.xml
                
                true
            
        
    

2、编写spring整合mybatis的核心文件：spring-mybatis.xml

3、编写实体类：User以及接口、实现类：

1、数据库中：
    id
    name
    pwd
    sex
    
2、实体User类：
    public class User {
    private int id;
    private String name;
    private String pwd;
    private String sex;
        //省略setter和getter方法
    }

3、UserMapper接口：
    public interface UserMapper {
    //查询所有的信息
  		 public List getUsers();
	}

4、 *** 作数据库（Mybatis）UserMapper.xml：
    
	
	
        
            select * from User;
        
	
            
5、UserMapperImpl实现类：
    public class UserMapperImpl implements UserMapper{
        //我们的所有的 *** 作，在原来：都使用SQLSession来执行，
        //现在：都使用SqlSessionTemplate
        private SqlSessionTemplate template;
        public void setTemplate(SqlSessionTemplate template){
            this.template=template;
        }
        @Override
        public List getUsers() {
            UserMapper mapper = template.getMapper(UserMapper.class);
            return mapper.getUsers();
        }
	}
 
4、测试类 
public class Spring_MybatisTest {
    @Test
    public void testThis(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-mybatis.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        List users = userMapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
    }
}
 
结果：
 
User{id=1, name='返回', pwd='456123', sex='h'}
User{id=2, name='dd', pwd='ty', sex='s'}
User{id=3, name='gd', pwd='为', sex='让'}
User{id=4, name='khd', pwd='456', sex='k'}
 
二：第二种方式（继承官方提供的类：SqlSessionDaoSupport）： 
1、再次编写一个UserMapperImpl2实现类：
 
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
    @Override
    public List getUsers() {
        return getSqlSession().getMapper(UserMapper.class).getUsers();
    }
}

直接省去了工厂类
 
2、配置文件中：
 
 
        
    
 
3、测试、结果一样
 
11、声明式事务： 
a、回顾事务： 
把一组业务当成一个业务来做；要么都成功，要么都失败！
事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
确保完整性和一致性；
 
事务ACID原则：
 
原子性
一致性
隔离性 
  
多个业务可能 *** 作同一个资源，防止数据损坏。
 
持久性 
  
事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中
 
 
b、spring中的事务管理 
声明式事务：AOP
编程式事务：需要在代码中，进行事务的管理
为什么需要事务？ 
  
若不配置事务，可能存在数据提交不一致的情况下；
若我们不在spring中去配置声明式事务，我们就需要在代码中手动配置事务
事务在项目的开发中十分重要，设计到数据的一致性和完整性问题，不容马虎！
 
 
1、接口UserMapper：
 
public interface UserMapper {
     List getUsers();

     int add(User user);

     int delete(@Param("id") int id);
}
 
2、 *** 作数据库的UserMapper.xml
 



    
        select * from User
    

    
        insert into user(id,name,pwd,sex)values(#{id},#{name},#{pwd},#{sex})
    

    
        delete from USER where id=#{id}
    

3、实现UserMapper接口的UserMapperImpl实现类

public class UserMapperImpl implements UserMapper {
    private SqlSessionTemplate template;

    public void setTemplate(SqlSessionTemplate template) {
        this.template = template;
    }
    @Override
    public List getUsers() {
        add(new User(11,"uuu","100","女"));

        int delete = delete(10);
        if(delete>0) System.out.println("ok");
        else System.out.println("shibi");
        return template.getMapper(UserMapper.class).getUsers();
    }
        @Override
    public int add(User user) {
        return template.getMapper(UserMapper.class).add(user);
    }

    @Override
    public int delete(int id) {
        return template.getMapper(UserMapper.class).delete(id);
    }
}

4、spring和mybatis整合的文件中 事务的文件：

....

    
        
    

    
    
    
        
        
        
            
            
            
            
            
        
    
    
    
        
        
    

    
        
    

5、测试：

public class SmaTEst {
    @Test
    public void TestSpM(){
        ApplicationContext context = new ClassPathXmlApplicationContext("mybatis-Spring.xml");
        UserMapper mapper = context.getBean("mapper", UserMapper.class);
        List users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
    }
}