Spring笔记

别人的笔记：(37条消息) 【狂神说】Spring学习笔记（全）_黑心白莲的博客-CSDN博客_狂神spring

简介

Spring是一个轻量级控制反转(IOC)和面向切面(AOP)的容器框架

Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架。

SSH：Struct2+Spring+Hibernate Hibernate：全自动的持久化框架

SSM：SpringMVC+Spring+Mybatis Mybatis：半自动框架

Springmvc 依赖 只需要导入第一个即可
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.16</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.16</version>
</dependency>

优点：

1、Spring是一个开源的免费的框架(容器)

2、Spring是一个轻量级、非入侵式的框架

3、控制反转(IOC)，面向切面编程(AOP)

4、支持事务的处理，对框架整合的支持

总结：Spring就是一个轻量级的控制反转(IOC)和面向切面槟城(AOP)的框架

拓展

Spring Boot

一个快速开发的脚手架

基于SpringBoot可以快速的开发单个为服务

约定大于配置

Spring Cloud

SpringCloud是基于SpringBoot实现的

因为大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC 承上启下

Spring弊端：

发展太久，违背了原来的理念，配置十分繁琐，人称“配置地域”

Spring组成

IOC理论推导

原来写程序步骤：

UserDao 接口

public interface UserDao {
    void getUsers();
}

UserDaoImpl 实现类

public class UserDaoImpl implements UserDao {
    public void getUsers() {
        System.out.println("获取用户信息");
    }
}

UserService 业务接口

public interface UserServer {
    void getUsers();
}

UserServiceImpl 业务实现类

public class UserServerImpl implements UserServer {
    private UserDao userDao = new UserDaoImpl();
    public void getUsers() {
        userDao.getUsers();
    }
}

当再写一个UserDaoImpl实现类如

public class MysqlImpl implements UserDao {
    public void getUsers() {
        System.out.println("获取到数据库");
    }
}

测试类

public class MyTest {
    public static void main(String[] args) {
        UserServer userServer = new UserServerImpl();
        userServer.getUsers();
    }
}

UserServiceImpl 业务实现类原先的改成下面这个，很麻烦

private UserDao userDao = new MysqlImpl();

UserServiceImpl实现类

利用set注入的思想

public class UserServerImpl implements UserServer {
    private UserDao userDao;
    //利用set进行动态实现值的注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void getUsers() {
        userDao.getUsers();
    }
}

测试类

public class MyTest {
    public static void main(String[] args) {
        UserServer userServer = new UserServerImpl();
        //((UserServerImpl) userServer).setUserDao(new UserDaoImpl());
        ((UserServerImpl) userServer).setUserDao(new MysqlImpl());
        userServer.getUsers();
    }
}

在之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码，如果程序代码量十分大，修改一次十分昂贵

使用一个Set接口实现

之前，程序是主动创建对象，控制权在程序员手上

使用set注入后，程序不再具有主动性，而是变成了被动的接收对象

这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建系统的耦合性大大降低，可以更加专注的在业务的实现上这是IOC的原型

IOC本质

控制反转IOC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IOC的一种方法，也有人认为DI只是IOC的另一种说法。没有IOC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

IOC是Spring框架的核心内容，使用多种方式完美的实现了IOC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IOC。

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从IOC容器中取出需要的对象。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

HelloSpring练习

hello封装类

public class Hello {
    private String str;
    public String getStr() {
        return str;
    }
    public void setStr(String str) {
        this.str = str;
    }
    @Override
    public String toString() {
        return str;
    }
}

beas.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

 <!--
    使用Spring来创建对象，在sping这些都成为Bean
    原先是 类型 变量名 = new 类型();
    Hello hello = new Hello();

    bean中的 id = 变量名
            class = new的对象
            property 相当于给对象中的属性赋值 set方法
            value :具体的值，基本数据类型
            ref ：引用Spring容器中创建好的对象

 -->
<bean id="hello" class="Hello">
    <property name="str" value="helloSpring"/>
</bean>

</beans>

测试类

public class Mytest {
    public static void main(String[] args) {
        //获取Spring的上下文对象   可以获取多个xml文件 new CPX快捷键
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       //获取文件
        ApplicationContext file  = new FileSystemXmlApplicationContext();
       //我们的对象现在都在Spring中的管理，我们要使用，直接去里面取出来就可以
        Hello hello = (Hello) context.getBean("hello");//强转成Hello
        System.out.println(hello.toString());
    }
}

在原本的业务逻辑上修改

增加xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
       使用Spring来创建对象，在sping这些都成为Bean
       原先是 类型 变量名 = new 类型();
       Hello hello = new Hello();

       bean中的 id = 变量名
               class = new的对象
               property 相当于给对象中的属性赋值 set方法
               value :赋值
               ref ：路径
    -->
<bean id="mysql" class="dao.MysqlImpl"></bean>
    <bean id="userdao" class="dao.UserDaoImpl"></bean>
    <bean id="userServerimpl" class="dao.UserServerImpl">
        <property name="userDao" ref="mysql"></property>
    </bean>
</beans>

测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserServerImpl userServerimpl = (UserServerImpl) context.getBean("userServerimpl");
        userServerimpl.getUsers();
    }
}

思考

Hello 对象是谁创建的 ? 【hello 对象是由Spring创建的
Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的

这个过程就叫控制反转 :

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

依赖注入 : 就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收

我们彻底不用再程序中去改动了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !

IOC创建对象

1、使用无参构造创建对象，默认。

<bean id="hello" class="Hello">
    <property name="str" value="helloSpring"/>
</bean>

2、假设使用有参构造创建对象

1、第一种下标赋值

<bean id="user" class="p.User">
        <!--第一种 下标赋值-->
        <constructor-arg index="0" value="UsersSpring"/>
    </bean>-->

2、二种方式，通过类型创建

<bean id="user" class="p.User">
        <!--第二种方式，通过类型创建
        不建议使用，当参数中有两个String 类型的参数-->
        <constructor-arg type="java.lang.String" value="UsersSpring"/>
    </bean>

3、

<!--第三种，直接通过参数名来设置-->
    <bean id="user" class="p.User">
        <constructor-arg name="name" value="UserSpring"/>
    </bean>

User类

public class User {
    private String name;
    public User(String name) {
        this.name = name;
        System.out.println("name="+name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

如果多写一个User_Two类

public class User_Two {
    private String name;
    public User_Two(String name) {
       System.out.println("User_Two被创建了");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

xml文件中

<!--第三种，直接通过参数名来设置-->
    <bean id="user" class="p.User">
        <constructor-arg name="name" value="UserSpring"/>
    </bean>
    <bean id="userT" class="p.UserTwo">
    </bean>

测试类中

public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user");//可以出现userTwo中的内容
        User user2 = (User) context.getBean("user");
        System.out.println(user==user2);//true  说明创建的是一个对象
    }

总结：

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

Spring配置

别名

如果添加了别名，我们我可以使用别名获取到这个对象

<!--将user起别名为 apple-->
<alias name="user" alias="apple"/>

测试类

//都可以使用 
User user = (User) context.getBean("user");
 User user = (User) context.getBean("apple");

Bean的配置

<!--
    id：bean的唯一标识符，也就相当于我们学的对象名
    class：bean 对象所对应的权限定名：包名+类型
    name：也是别名，而且name。可以同时去多个别名
-->
<bean id="user" class="p.User" name="user2 u2,u3;u4"><!--也能用空格、分号分开-->
<bean id="user" class="p.User" name="user2,u2">
     <constructor-arg name="name" value="UserSpring"/>
</bean>

import

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

假设现在项目有多个人开发，负责不同类的开发，不同的类需要注册在不同的bean中，可以利用import将所有人的beans.xml合并为一个总的

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

beans,xml中有相同的配置，也合并在一起，随便选一个调用

总xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

     <import resource="beans1.xml"/>
     <import resource="beans2.xml"/>
     <import resource="beans3.xml"/>
</beans>

beans1.xml beans2.xml beans3.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="p.User" name="user2,u2">
     <constructor-arg name="name" value="UserSpring"/>
    </bean>

</beans>

依赖注入

1、构造器注入

前面已经说过了

2、set方式注入[重点]

依赖注入：set注入

依赖：bean对象的创建依赖于容器

注入：bean对象中的所有属性，由容器来注入

【环境搭建】

1、复杂类型

public class Address {
    private String address;
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

2、真实测试对象

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<Student,String> card;
    private Set<String> games;
    private String wife;
    get/set方法
}

xml配置类

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student" class="Student">
        <!--第一种 普通值注入-->
        <property name="name" value="张三"/>
    </bean>
</beans>

测试类只能获取name一个属性的值，获取其他值会报null

public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.getName());
    }

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="address" class="Address">
        <property name="address" value="山西"/>
    </bean>

    <bean id="student" class="Student">
        <!--第一种 普通值注入*****************-->
        <property name="name" value="张三"/>

        <!--引用注入*****************-->
        <property name="address" ref="address"/>
        <!--数组注入*******************-->
       <property name="books">
           <array>
               <value>红楼梦</value>
               <value>西游记</value>
               <value>水浒传</value>
               <value>三国演义</value>
           </array>
       </property>
        <!--4、List注入********************-->
        <property name="hobbys">
            <list>
                <value>听歌</value>
                <value>看电影</value>
                <value>爬山</value>
            </list>
        </property>
        <!--Map注入********************-->
        <property name="card">
            <map>
                <entry key="中国邮政" value="456456456465456"/>
                <entry key="建设" value="1456682255511"/>
            </map>
        </property>
        <!--set注入**********************-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>BOB</value>
                <value>COC</value>
            </set>
        </property>
        <!--Null注入*********************-->
        <property name="wife">
            <null/>
        </property>
        <!--
        Properties注入*****************
        key=value
        url =root
        -->
        <property name="info">
            <props>
                <prop key="学号">20190604</prop>
                <prop key="性别">男</prop>
                <prop key="姓名">小明</prop>
                <prop key="url">root</prop>
            </props>
        </property>
    </bean>
</beans>

```java
//测试类   
public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student);
    }

3、拓展方式

可以使用p命令空间和c命令空间进行注入

p命令注入

在xml文件中加入p标签的约束

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

Users类

public class User {
    private String name;
    private int age;
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public User() {
    }
    get/set方法
}

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

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

       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="user" class="User" p:name="张三" p:age="22"/>

    <!--相当于这个-->
    <bean id="user2" class="User">
        <property name="name" value="张三"/>
        <property name="age" value="22"/>
    </bean>
</beans>

c命令注入

在xml文件中插入c标签的约束

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

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="user" class="User" c:name="张三" c:age="22"/>
    <!--根据有参构造器的下表赋值-->
    <bean id="user2" class="User" c:_0="张三" c:_1="22"/>
</beans>

注意：

p命名和c命名不能直接使用，需要导入xml约束

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

Bean的作用域

重点前两个

1、单例模式(Spring默认机制) 重要的

 <bean id="user" class="User" c:name="张三" c:age="22" scope="singleton"/>

```java
 User user = context.getBean("user", User.class);//在后面加入 User.class 不用强转了
        User user2 = context.getBean("user", User.class);
        System.out.println(user==user2);//true

2、原型模式：每次从容器中get，都会产生一个新对象

<bean id="user" class="User" c:name="张三" c:age="22" scope="prototype"/>

```java
 User user = context.getBean("user", User.class);
        User user2 = context.getBean("user", User.class);
        System.out.println(user==user2);//false

3、其余的request、session、application，这些只能在web开发中使用

Bean的自动装配

1、自动装配是Spring满足bean依赖一种方式

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

Spring有三种装配的方式

1、在xml找那个显示的配置

2、在java中显示配置

3、隐试的自动装配bean【重要的】

测试

手动装配环境搭建

一个人有两个宠物

xml配置

<bean id="cat" class="com.p.Cat"/>
    <bean id="dog" class="com.p.Dog"/>
    <bean id="people" class="com.p.People" autowire="byName">
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
        <property name="name" value="张三"/>
    </bean>

ByName自动装配

在bean标签后面添加组件 autowire=“byName” id不能省略

必须和set方法一致

   public void setCat(Cat cat) {
        this.cat = cat;
    }
 public void setDog(Dog dog) {
        this.dog = dog;
    }
  public void setName(String name) {
        this.name = name;
    }

```xml
<bean id="cat" class="com.p.Cat"/>
<bean id="dog" class="com.p.Dog"/>
<bean id="people" class="com.p.People" autowire="byName">
        <property name="name" value="张三"/>
 </bean>
<!--可以使用-->
<!--当改变id名 就会报空指针异常-->
<bean id="cat" class="com.p.Cat"/>
<bean id="dog22" class="com.p.Dog"/>

byName：会自动在容器上下文查找，和自己对象set方法的对应的 bean id

ByType自动装配

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

在bean标签后面添加组件 autowire=“byType” id可以省略

<!--当改变id名 可以使用，但要保证id唯一-->
<bean id="cat" class="com.p.Cat"/>
<bean id="dog22" class="com.p.Dog"/>
<bean class="com.p.Dog"/>
<bean id="people" class="com.p.People" autowire="byType">
        <property name="name" value="张三"/>
 </bean>
<!--可以使用-->

小结

byname的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致

bytype的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性类型一致

使用注解实现自动装配

jdk1.5支持的注解，Spring2.5就支持注解了

可以省略set方法

要使用注解须知：

1、导入约束

1、xmlns:context="http://www.springframework.org/schema/context"
2、xsi:schemaLocation=http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd"

2、配置注解的支持【重要】

<!--开启注解的支持    -->
       <context:annotation-config/>

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">

        <!--开启注解的支持    -->
        <context:annotation-config/>
</beans>

原先的people类

    @Autowired//自动配置
    private Cat cat;
    @Autowired//自动配置
    private Dog dog;
    private String name;
    //可以省略set方法

xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">
>
    <!--开启注解的支持    -->
    <context:annotation-config/>
    <bean id="cat" class="com.p.Cat"/>
    <bean id="dog" class="com.p.Dog"/>
    <bean id="people" class="com.p.People"/>


</beans>

@AutoWired

直接在属性上使用即可，也可以在set方式上使用

使用AutoWired可以不用编写set方法，前提是自动装配的属性在IOC(Spring)容器中存在，且符合名字byname

科普：

@Nullable

@Nullable 字段标记了这个注解，说明这个字段可以为null

//不会报空指针错误 
public void setName(@Nullable String name) {
        this.name = name;
    }
//如果显示定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
@Autowired(required = false)
    private Cat cat;

@Quailfier(value==“xxx”)

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】王完成的时候，我们可以使用@Quailfier(value==“xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入

    @Autowired
    @Qualifier(value = "cat222")
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog222")
    private Dog dog;
    private String name;

```xml
  <bean id="cat" class="com.p.Cat"/>
    <bean id="dog" class="com.p.Dog"/>
    <bean id="cat222" class="com.p.Cat"/>
    <bean id="dog222" class="com.p.Dog"/>

@Resource

java原生的注解，在bean配置中根据id查询，查询不到，再根据class查询，如果都查询不到就报错

    @Resource
    private Cat cat;

```xml
    <!--开启注解的支持    -->
    <context:annotation-config/>
    <bean id="cat" class="com.p.Cat"/>
    <bean id="dog" class="com.p.Dog"/>
    <bean id="people" class="com.p.People"/>

@Resource(name=“xxx”)

指定唯一的id属性值

    @Resource(name="cat22")
    private Cat cat;

```xml
<bean id="cat" class="com.p.Cat"/>
<bean id="cat22" class="com.p.Cat"/><!--先找这个-->
    <bean id="dog" class="com.p.Dog"/>
    <bean id="people" class="com.p.People"/>

小结：

@Resource和@AutoWired的区别：

1、都是用来自动装配的，都可以放在属性字段上

2、@AutoWired 通过byType的方式实现，而且必须要求这个对象存在【常用】

3、@Resource 默认通过byname的方式实现，如果找不到名字，则通过byType实现，如果两个都找不到的情况下，就报错

4、执行顺序不同：@AutoWired 通过byType的方式实现。

@Resource 默认通过byname的方式实现**

使用注解开发

在Spring4之后，要使用注解开发，必须要保证aop的包导入了

在使用注解需要导入context约束，增加注解支持

1、xml自动注解配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启注解的支持    -->
    <context:annotation-config/>
    <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.p"/>
</beans>

@component:组件，放在类上，说明这个类被Spring管理了，就是bean

使用：

java类 User类

/*
    等价于 <bean id = user class="com.p.user"/>
    @Component:组件
 */
@Component
public class User {
    public String name="张三";
}

xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启注解的支持    -->
    <context:annotation-config/>
    <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.p"/>
</beans>

测试类

 public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //是获取该类的类名小写
        User user = context.getBean("user", User.class);
        System.out.println(user.name);
 }

1、bean

2、属性如何注入

@Component
public class User {
    //相当于<property name="name" value="张三"/>
    @Value("张三")
    public String name;
}

```java
@Component
public class User {
    public String name;
    //相当于<property name="name" value="张三"/>
    @Value("张三")
    public void setName(String name) {
        this.name = name;
    }
}

3、衍生的注解

在web开发中，会按照mvc三层架构分层！

dao【@Repository】组件的意思

@Repository
public class UserDao {
}

service【@Service】组件的意思

@Service
public class UserService {
}

controller【@Controller】组件的意思

被Spring托管

@Controller
public class UserController {
}

这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean

4、自动装配置

1、@Autowired：自动装配通过类型，名字

如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value=“xxx”)

2、@nullable：字段标记了这个注解，说明这个字段可以为null

3、@Resource：自动装配名字，类型

5、作用域

@Scope

@Scope(“singleton”) ：单例模式(Spring默认机制) 重要的

以前在xml文件中配置

 <bean id="user" class="User" c:name="张三" c:age="22" scope="singleton"/>

现在在实体类中配置

@Scope("singleton")
public class User {}

@Scope(“prototype”)：默认

6、小结

xml与注解

xml：更加万能，使用与任何场合，维护简单方便

注解：不是自己的类使用不了，维护相对复杂

最佳实践：

xml用来管理bean

注解只负责完成属性的注入

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

    <!--开启注解的支持    -->
    <context:annotation-config/>
    <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.p"/>

使用java的方式配置Spring

完全不适用Spring的xml配置，全权交给java来做

JavaConfig是Spring的一个子项目，在Spring4之后，成为一个核心功能

实体类

@Component：代表是一个组件

这个注解的意思，就是这个类被Spring接管了，注册到容器中
不加全盘扫描不用加

@Value(“张三”)//属性注入值

//这个注解的意思，就是这个类被Spring接管了，注册到容器中
@Component//不加全盘扫描不用加
public class User {
    private String name;

    public String getName() {
        return name;
    }
    @Value("张三")//属性注入值
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

配置类

使用java文件来配置文件，不用xml文件进行配置

1、@Import(MyConfig2.class)//引入其他的配置类 xml中的import组件

2、@Configuration：代表这个是一个配置类，就和我们之前用的 beans.xml

3、@Component(“com.p”)//指定扫描路径

4、@Bean：注册一个bean，就相当于我们之前写的一个bean标签

**这个方法的名字，就相当于bean标签的id  id="getUser"**
**这个方法的返回值，就相当于bean标签的class属性  class="com.p.User"**

/*
    配置类 类似于xml的配置类
 */
//代表这个是一个配置类，就和我们之前用的 beans.xml
@Configuration
@Component("com.p")//指定扫描路径
@Import(MyConfig2.class)//引入其他的配置类  xml中的import组件
public class MyConfig {

    @Bean
    /*注册一个bena，就相当于我们之前写的一个bean标签
    这个方法的名字，就相当于bean标签的id  id="getuser"
    这个方法的返回值，就相当于bean标签的class属性  class="com.p.User"
    */
    public User getUser(){
        return new User();//返回要注入到bean的对象
    }
}

另一个配置类

让主类导入时主类用import引用子类

@Configuration
public class MyConfig2 {
}

测试类

1、快捷键：new ACAC

ApplicationContext context = new AnnotationConfigApplicationContext("配置类的class文件");

```java
public class MyTest {
    public static void main(String[] args) {
        //  new ACAC
        //如果完全使用了配置类方式去做，就只能通过AnnotationConfig 上下文来获取容器，
        //通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        User getUser = context.getBean("getUser",User.class);
        System.out.println(getUser.getName());
    }
}

这种纯java的配置方式，在SpringBoot中随处可见

代理模式

为什么学习代理模式：

因为这个就是SpringAOP的顶层【SpringAOP 和SpringMVC】必问

代理模式的分类：静态和动态

静态代理：

角色分析：

抽象角色：一般会使用接口或抽象类类解决

真实角色：被代理的角色

代理角色：代理真实角色，代理真实角色后，一般会做一些附属操作

客户：访问代理对象的人

代操作：

1、接口

//租房操作的接口
public interface Rent {
    void zufang();
}

2、真实角色

在添加业务时，真实角色不用去操作

//房东类，继承租房的操作
public class Host_fangdong implements Rent{
    public void zufang() {
        System.out.println("房东要出租房子");
    }
}

3、代理角色

添加业务在代理角色这里操作

//中介类，中间类， 继承租房操作，实现房东租房的操作实现
//中介可以加一些操作,不止给房东租房一种操作
public class Proxy implements Rent{
    private Host_fangdong host;

    public Proxy() {
    }

     //这里最好用set注入的方法，进行注入，而不用
    public Proxy(Host_fangdong host) {
        this.host = host;
    }

    //主要操作*******************************
    public void zufang() {
        //中介的操作
        LokeHouse();
        //实现房东租房的操作
        host.zufang();
        //中介的操作
        hetong();
        //中介的操作
        fare();
    }
    //中介再加入一些其他操作 如：看房，签合同，收钱等操作
    public void LokeHouse(){
        System.out.println("中介给用户看房子");
    }
    public void hetong(){
        System.out.println("中介给用户签合同");
    }
    //收费操作
    public void fare(){
        System.out.println("中介收费");
    }
}

4、客户端访问代理角色

public class User {
    public static void main(String[] args) {
        //房东要出租房子
        Host_fangdong host = new Host_fangdong();
        //代理，中介帮房东出租房子， 代理一般会有其他操作
        Proxy proxy  = new Proxy(host);
        //你不用面对房东，直接找中介租房即可
        proxy.zufang();
    }
}

代理模式的好处：

1、可以使真实角色的操作更加纯粹

2、公共业务就交给代理角色，实现了业务的分工

3、公共业务发生扩展的时候，方便集中管理

缺点：

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

动态代理：

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

动态代理的代理类是动态生成的，不是直接写好的！

动态代理分为两大类：基于接口的动态代理，基于类的动态代理

1、基于接口：JDK动态代理【使用这个】

2、基于类：cglib

3、java字节码实现：javasist

需要了解两个类：

1、Proxy—-代理的意思

提供了静态方法来创建类似于接口实例的对象，但允许自定义的方法调用。要为某个接口创建代理实例

| newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) |
| ———————————————————— |
| 返回指定接口的代理实例，该代理实例将方法调用分派给指定的调用处理程序。 |

ClassLoader loader：被代理类的类加载器

Class[] interfaces：被代理类的所有实现接口的Class对象【要代理的那个类的接口】

InvocationHandler h：继承InvocationHandler这个接口的类

2、InvocationHandler—-调用处理程序代理类要用的接口

是由代理实例的调用处理程序实现的接口

在代理类【中介类】继承这个接口，重写以上方法

好处：

1、可以使真实角色的操作更加纯粹

2、公共业务就交给代理角色，实现了业务的分工

3、公共业务发生扩展的时候，方便集中管理

4、一个动态代理类代理的是一个接口，一般就是对应的一类业务

5、一个动态代理列可以代理多个类，只要是实现了同一个接口即可。

代码实现：

接口类

public interface Controller {
    //用户增加操作
    void add();
    //用户删除
    void delete();
    //用户修改
    void update();
    //用户查询
    void select();
}

真实角色:

/真实角色类
public class User implements Controller{
    public void add() {
        System.out.println("增加");
    }
    public void delete() {
        System.out.println("删除");
    }
    public void update() {
        System.out.println("修改");
    }
    public void select() {
        System.out.println("查看");
    }
}

动态代理的类当成一个工具类

//动态代理类，自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }

    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        //动态代理的本质，就是使用反射机制实现
        Object result = method.invoke(target, args);
        return result;
    }
    //增加的其他方法实现
    public void log(String meg){
        System.out.println("执行了"+meg+"方法");
    }
}

访问代理对象的人

public class Client {
    public static void main(String[] args) {
        //真实角色
        User user = new User();
        //代理角色，不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序来处理角色，处理我们要调用的接口对象
        pih.setTarget(user);//设置要代理的对象
        //动态生成代理类
        Controller proxy = (Controller) pih.getProxy();
        proxy.add();
    }
}

AOP

需要导入包

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
</dependency>

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

AOP在Spring中的作用

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

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

代码实现:

方法一：利用原生Spring API接口实现【主要是SpringAPI接口实现】

接口

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

实现类

public class UserServiceImp implements UserService {
    public void add() {
        System.out.println("增加");
    }
    public void delete() {
        System.out.println("删除");
    }
    public void update() {
        System.out.println("修改");
    }
    public void select() {
        System.out.println("查看");
    }
}

前置增强实现日志功能

//前置增强 日志
public class log implements MethodBeforeAdvice {
    /*
    method:要执行的目标对象的方法
    args：参数
    target：目标对象
 */
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

后置增强，并返回值

//后置增强 有返回值的接口
//AfterAdvice 无返回值的后置增强接口
public class AfterLog implements AfterReturningAdvice {
    //returnValue：返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行力"+method.getName()+"方法,返回结果为"+returnValue);
    }
}

xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">


    <!--注册beean-->
    <bean id="userService" class="com.p.UserServiceImp"/>
    <bean id="log" class="com.log.log"/>
    <bean id="afterLog" class="com.log.AfterLog"/>

    <!--方式一：使用原生Spring注册Aop-->
    <!--配置AOP：需要导入AOP的约束文件    <aop:config  回车-->
    <aop:config>
        <!--pointcut：切入、切入的意思-->
        <!--切入点：execution(要执行的位置  修饰词 返回值 类名 方法名)-->
                                        <!--—* * * * *  代表是任意的-->
        <aop:pointcut id="pointcut" expression="execution(* com.p.UserServiceImp.*(..))"/>
                                                            <!--*:代表是任意的东西  com.p.UserServiceImp：需要切入点的类
                                                                com.p.UserServiceImp.*：代表是这个类中所有方法
                                                                com.p.UserServiceImp.*(..)：代表这个方法有任意的参数-->
        <!--执行环绕  advisor:环绕-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

测试类：

   public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //动态代理代理的是接口
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }

方式二：自定义来实现AOP【只要是切面定义】

自定义类

public class DiyPointCut {
    public void before(){
        System.out.println("==========方法执行前===========");
    }
    public void after(){
        System.out.println("==========方法执行后==========");
    }
}

xml文件配置

<!--注册bean-->
    <bean id="userService" class="com.p.UserServiceImp"/>
    <bean id="log" class="com.log.log"/>
    <bean id="afterLog" class="com.log.AfterLog"/>

    <!--方式二：自定义类-->
    <!--注册自定义的bean文件-->
    <bean id="diy" class="com.diy.DiyPointCut"/>
    <!--配置AOP-->
    <aop:config>
        <!--自定义切面，ref 要引用的类-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* com.p.UserServiceImp.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

测试类

 public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //动态代理代理的是接口
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
   }

方式三：使用注解实现

自定义类

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

    @Before("execution(* com.p.UserServiceImp.*(..))")
    public void before(){
        System.out.println("方法执行前");
    }
    @After("execution(* com.p.UserServiceImp.*(..))")
    public void  after(){
        System.out.println("方法执行后");
    }

    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点；
    @Around("execution(* com.kuang.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);
    }

}

xml配置

    <!--方式三：使用注解-->
    <bean id="annotationPointCut" class="com.diy.Diy2"/>
    <!--开启注解支持！ JDK(默认是 proxy-target-class="false")  cglib（proxy-target-class="true"）-->
    <aop:aspectj-autoproxy/>

Spring和Mybatis整合

1、导包

junit
mybatis
mysql数据库
spring相关的
aop植入
mybatis-spring【新的】

```xml
 <dependencies>
        <!--junit包-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    <!--mysql包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--mybatis包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <!--spring操作数据库的话，还需要spring-jdbc包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <!--spring整合mybatis需要-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.2</version>
        </dependency>
    </dependencies>

2、编写配置文件

3、测试

回忆mybatis

1、编写实体类

User实体类

 private int id;
 private String name;
 private String pwd;
get/set方法

2、编写核心配置文件

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--给实体类起别名-->
    <typeAliases>
        <package name="com.p.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!--绑定接口-->
    <mappers>
        <mapper class="com.p.mapper.UserMapper"/>
    </mappers>
</configuration>

3、编写接口

UserMpaaer

public interface UserMapper {
    List<User> getUsers();
}

4、编写Mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.p.mapper.UserMapper">
    <select id="getUsers" resultType="user">
        select * from mybatis.user;
    </select>
</mapper>

5、测试

 @Test
    public void UserMapper() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory SqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = SqlSessionFactory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

Mybatis-spring

什么是 MyBatis-Spring？

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许 MyBatis 参与到 Spring 的事务管理之中，创建映射器 mapper 和 SqlSession 并注入到 bean 中，以及将 Mybatis 的异常转换为 Spring 的 DataAccessException。最终，可以做到应用代码不依赖于 MyBatis，Spring 或 MyBatis-Spring。

在开始使用 MyBatis-Spring 之前，你需要先熟悉 Spring 和 MyBatis 这两个框架和有关它们的术语。这很重要

MyBatis-Spring 需要以下版本：

| MyBatis-Spring | MyBatis | Spring Framework | Spring Batch | Java |
| ————– | ——- | —————- | ———— | ——- |
| 2.0 | 3.5+ | 5.0+ | 4.0+ | Java 8+ |
| 1.3 | 3.4+ | 3.2.2+ | 2.1+ | Java 6+ |

入门

导入jar包

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>2.0.7</version>
</dependency>

1、编写数据源配置

spring-dao.xml

代替原先的mybatis-config.xml中的数据库连接

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">


    <!--DataSource:使用Spring的数据源替换Mybatis的配置  c3p0  dbcp  druid
    这里使用Spring提供的JDBC
    需要导入<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>-->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!--配置sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource"/>
        <!--绑定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!--别名也可以在这里做-->
        <!--<property name="typeAliases" value="com.p.pojo.User"/>-->
        <!--也可以在这里绑定Mapper-->
        <!--<property name="mapperLocations" value="classpath:com/p/mapper/*.xml"/>-->
    </bean>
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入SqlSessionFactory ，因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <bean id="userMapper" class="com.p.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
     </bean>
</beans>

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--给实体类起别名-->
    <typeAliases>
        <package name="com.p.pojo"/>
    </typeAliases>

    <!--绑定接口-->
    <mappers>
        <mapper class="com.p.mapper.UserMapper"/>
    </mappers>
</configuration>

2、SqlSessionFactory

可以使用 SqlSessionFactory 作为构造方法的参数来创建 SqlSessionTemplate 对象。

<!--配置sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource"/>
        <!--绑定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>

3、sqlSessionTemplate

SqlSessionTemplate 是 MyBatis-Spring 的核心。作为 SqlSession 的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession。 SqlSessionTemplate 是线程安全的，可以被多个 DAO 或映射器所共享使用。

</bean>
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入SqlSessionFactory ，因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

4、给接口加实现类

UserMapper接口

public interface UserMapper {
    List<User> getUsers();
}

UserMapper.xml配置文件

<mapper namespace="com.p.mapper.UserMapper">
    <select id="getUsers" resultType="user">
        select * from mybatis.user;
    </select>
</mapper>

UserMapperImpl 实现类

public class UserMapperImpl implements UserMapper {
    //我们所有操作，都使用sqlSession来执行，在原来，现在都是用SqlSessionTemplate
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> getUsers() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.getUsers();
    }
}

5、将自己写的实现类，注入到Spring中

<bean id="userMapper" class="com.p.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
     </bean>

6、测试

 @Test
    public void UserMapper() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        List<User> users = userMapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
    }

SqlSessionDaoSupport

官方文档：

不用写SqlSession

SqlSessionDaoSupport 是一个抽象的支持类，用来为你提供 SqlSession。调用 getSqlSession() 方法你会得到一个 SqlSessionTemplate，之后可以用于执行 SQL 方法，就像下面这样:

public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {
  public User getUser(String userId) {
    return getSqlSession().selectOne("org.mybatis.spring.sample.mapper.UserMapper.getUser", userId);
  }
}

在这个类里面，通常更倾向于使用 MapperFactoryBean，因为它不需要额外的代码。但是，如果你需要在 DAO 中做其它非 MyBatis 的工作或需要一个非抽象的实现类，那么这个类就很有用了。

SqlSessionDaoSupport 需要通过属性设置一个 sqlSessionFactory 或 SqlSessionTemplate。如果两个属性都被设置了，那么 SqlSessionFactory 将被忽略。

假设类 UserMapperImpl 是 SqlSessionDaoSupport 的子类，可以编写如下的 Spring 配置来执行设置：

<bean id="userDao" class="org.mybatis.spring.sample.dao.UserDaoImpl">
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

程序中实现

接口实现

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
    public List<User> getUsers() {
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.getUsers();

        //优化成一行代码
        //return getSqlSession().getMapper(UserMapper.class).getUsers();

    }

在spring中注册改类

可以把之前的sqlSession去掉

<bean id="userMapper" class="com.p.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
     </bean>

换成下面这种

 <bean id="userMapper2" class="com.p.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

测试

 @Test
    public void UserMapper() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
        List<User> users = userMapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
    }

声明时事务

1、回顾事务

把一组业务当成一个业务来做；要么都成功，要么都失败

事务在项目开发中，十分重要，涉及到数据的一致性问题

确保完整性和一致性

事务ACID原则：

原子性

一致性

隔离性

多个业务可能操作同一个资源，防止数据损坏

持久性

事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中。

2、事务案例

实体类

private int id;
private String name;
private String pwd;

Mapper方法

UserMapper

public interface UserMapper {
    List<User> getUsers();

    //添加用户
    public int addUser(User user);
    //删除一个用户
    public int deleteUser(int id);
}

UserMapper.xml

<mapper namespace="com.p.mapper.UserMapper">
    <select id="getUsers" resultType="user">
        select * from mybatis.user;
    </select>

    <insert id="addUser" parameterType="user">
        insert into mybatis.user (id, name, pwd) values (#{id}, #{name}, #{pwd});
    </insert>

    <delete id="deleteUser" parameterType="_int">
        delete from mybatis.user where id=#{id};
    </delete>
</mapper>

UserMapperImpl接口实现类

public class UserMapperImpl implements UserMapper {
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> getUsers() {
        User user = new User(7,"777","7777");
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        //添加一个用户
        mapper.addUser(user);
        //删除一个指定的用户
        mapper.deleteUser(6);
        return mapper.getUsers();
    }

    public int addUser(User user) {
        return sqlSession.getMapper(UserMapper.class).addUser(user);
    }

    public int deleteUser(int id) {
        return sqlSession.getMapper(UserMapper.class).deleteUser(6);
    }
}

配置文件

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--给实体类起别名-->
    <typeAliases>
        <package name="com.p.pojo"/>
    </typeAliases>

    <!--绑定接口-->
    <mappers>
        <mapper class="com.p.mapper.UserMapper"/>
    </mappers>
</configuration>

spring_beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">

    <!--使用spring带的jdbc数据库-->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!--配置sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource"/>
        <!--绑定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <!--注册实现类-->
    <bean id="userMapper" class="com.p.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
</beans>

测试

 @Test
    public void getUser(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring_beans.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        List<User> users = userMapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
    }

如果在删除语句有误时，会将数据添加上去，而不会删除指定用户

3、spring中的事务管理

一个使用 MyBatis-Spring 的其中一个主要原因是它允许 MyBatis 参与到 Spring 的事务管理中。而不是给 MyBatis 创建一个新的专用事务管理器，MyBatis-Spring 借助了 Spring 中的 DataSourceTransactionManager 来实现事务管理。

声明式事务：AOP

使用Spring管理事务，注意头文件的约束导入 : tx

xmlns:tx="http://www.springframework.org/schema/tx"

http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">

在spring-beans.xml中加入AOP横切事务

<!--JDBC事务  配置声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="datasource"/>
    </bean>

    <!--结合AOP实现事务的植入-->
    <!--配置事务通知：-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给哪些方法配置事务-->
        <!--配置事务的传播特性-->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--配置事务切入-->
    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.p.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>

spring事务传播特性：

事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：

propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作

Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。

Spring笔记

简介

优点：

拓展

Spring弊端：

Spring组成

IOC理论推导

IOC本质

HelloSpring练习

在原本的业务逻辑上修改

增加xml配置文件

测试类

思考

IOC创建对象

Spring配置

别名

Bean的配置

import

依赖注入

1、构造器注入

2、set方式注入[重点]

3、拓展方式

p命令注入

c命令注入

注意：

Bean的作用域

Bean的自动装配

测试

ByName自动装配

ByType自动装配

小结

使用注解实现自动装配

@AutoWired

科普：

@Nullable

@Quailfier(value==“xxx”)

@Resource

@Resource(name=“xxx”)

小结：

@Resource和@AutoWired的区别：

使用注解开发

1、bean

2、属性如何注入

3、衍生的注解

dao【@Repository】 组件的意思

service【@Service】组件的意思

controller【@Controller】 组件的意思

4、自动装配置

5、作用域

6、小结

xml与注解

最佳实践：

使用java的方式配置Spring

实体类

配置类

另一个配置类

测试类

代理模式

为什么学习代理模式：

代理模式的分类：静态和动态

静态代理：

代操作：

1、接口

2、真实角色

3、代理角色

4、客户端访问代理角色

代理模式的好处：

缺点：

动态代理：

需要了解两个类：

1、Proxy—-代理的意思

2、InvocationHandler—-调用处理程序 代理类要用的接口

好处：

代码实现：

AOP

AOP在Spring中的作用

代码实现:

方法一：利用原生Spring API接口实现【主要是SpringAPI接口实现】

接口

实现类

dao【@Repository】组件的意思

controller【@Controller】组件的意思

2、InvocationHandler—-调用处理程序代理类要用的接口

前置增强实现日志功能