Spring

1、Spring

1.1、简介

Spring : 春天 --->给软件行业带来了春天

2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。

2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。

很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。

Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术

官网 : http://spring.io/

官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/

GitHub : https://github.com/spring-projects

导包

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.9</version>
</dependency>


<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.9</version>
</dependency>

1.2、优点

1、Spring是一个开源免费的框架 , 容器 .

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

3、控制反转 IoC , 面向切面 Aop

4、对事物的支持 , 对框架的支持

.......

一句话概括：

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

1.3、组成

1.4、SpringBoot和SpringCloud

SpringBoot

快速开发
基于SpringBoot可以快速的开发单个微服务
约定大于配置

SpringCloud

SpringCloud基于SpringBoot实现的

SpringBoot需要完全掌握Spring和SpringMVC

弊端：Spring发展了太久，配置十分繁琐，人称配置地狱！---SpringBoot后彻底解放

2、IOC理论推导

2.1、之前的业务：

UserDao.java

package com.badwei.dao;

public interface UserDao {
    void getUser();
}

UserDaoImpl.java

package com.badwei.dao;

public class UserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("默认获取用户的数据");
    }
}

UserDaoMysqlImpl.java

package com.badwei.dao;

public class UserDaoMysqlImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("Mysql获取用户数据");
    }
}

UserDaoOracleImpl.java

package com.badwei.dao;

public class UserDaoOracleImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("Oracle获取用户数据");
    }
}

UserService.java

package com.badwei.service;

public interface UserService {
    void getUser();
}

UserServiceImpl

package com.badwei.service;

import com.badwei.dao.UserDao;
import com.badwei.dao.UserDaoImpl;
import com.badwei.dao.UserDaoMysqlImpl;
import com.badwei.dao.UserDaoOracleImpl;

public class UserServiceImpl implements UserService{


    private UserDao userDao = new UserDaoImpl();//要想使用某个对象，得在这创建对象
//    private UserDao userDao = new UserDaoMysqlImpl();//切换对象，每次都要修改
//    private UserDao userDao = new UserDaoOracleImpl();

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

2.2、使用set注入后的业务：

其他不变，UserServiceImpl.java修改为

package com.badwei.service;

import com.badwei.dao.UserDao;
import com.badwei.dao.UserDaoImpl;
import com.badwei.dao.UserDaoMysqlImpl;
import com.badwei.dao.UserDaoOracleImpl;

public class UserServiceImpl implements UserService{


//    private UserDao userDao = new UserDaoImpl();
//    private UserDao userDao = new UserDaoMysqlImpl();
//    private UserDao userDao = new UserDaoOracleImpl();

    private UserDao userDao;//这里只定义接口，然后提供set方法，让用户自己去定义具体的实现类

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

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码！-牵一发而动全身！如果代码十分庞大，修改一次的成本很高！

区别:

早期，程序是主动创建对象，控制权在程序猿手上！
使用了set注入后，程序不再具有主动性，而变成了被动的接受对象！

2.3、总结

这种思想，本质上解决了问题，程序员不用再去管理对象的创建

系统的耦合性大大降低，可以更专注在业务的实现上

这是IOC（控制反转）的原型，反转(理解)：主动权交给了用户

2.4、IOC本质

控制反转 IOC（Inversion of Control）是一种设计思想，DI（依赖注入）是实现IOC的一种方法。

没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，

控制反转后将对象的创建转移给第三方，

个人认为所谓控制反转就是：获得依赖对象的方式反转了。

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

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

3、HelloSpring

3.1、HelloSpring实现

1、编写一个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 "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

2、编写我们的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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
	bean就是java对象 , 由Spring创建和管理
    Hello hello = new Hello();

    id = 变量名
    class = new 的对象
    property 相当于给对象的额属性设置一个值
    -->
    <bean id="hello" class="com.badwei.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>

</beans>

3、我们可以去进行测试了 .

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

3.2、思考：

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

这个过程就叫控制反转 :

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

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

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

可以通过newClassPathXmlApplicationContext去浏览一下底层源码 .

3.3、修改spring-01-ioc

新增一个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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- services -->

    <bean id="mysqlImpl" class="com.badwei.dao.UserDaoMysqlImpl" />
    <bean id="oracleImpl" class="com.badwei.dao.UserDaoOracleImpl" />
    <bean id="userDaoImpl" class="com.badwei.dao.UserDaoImpl" />

    <bean id="userServiceImpl" class="com.badwei.service.UserServiceImpl" >
<!--引用spring容器中创建好的对象
value:具体的值，基本数据类型-->
        <property name="userDao" ref="mysqlImpl" />
<!--        <property name="userDao" ref="oracleImpl" />-->
<!--        <property name="userDao" ref="userDaoImpl" />-->
        <!--这里只需要修改配置文件就可以达到new 不同对象的效果-->
    </bean>

</beans>

测试

public class MyTest {
    public static void main(String[] args) {

        ApplicationContext cotext = new ClassPathXmlApplicationContext("beans.xml");

        UserServiceImpl userServiceImpl = (UserServiceImpl) cotext.getBean("userServiceImpl");

        userServiceImpl.getUser();


    }
}

4、IOC创建对象方式

4.1、通过无参构造来创建

1.User.java

package com.badwei.pojo;

public class User {
    private String name;

    public User(){
        System.out.println("User的无参构造");
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

2.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--无参构造的方式（用的是无参构造器构造，set方法赋值）-->
    <bean id="user" class="com.badwei.pojo.User">
        <property name="name" value="岩弟弟"/>
    </bean>
    
</beans>

3.测试类

public class MyTest {
    public static void main(String[] args) {

        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //上面已经创建了对象了
        User user = (User) context.getBean("user");

        System.out.println(user);

    }
}

结果可以发现，在调用show方法之前，User对象已经通过无参构造初始化了！

4.2、通过有参构造方法来创建

bean.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">

<!--无参构造的方式（用的是无参构造器构造，set方法注入）-->
<!--    <bean id="user" class="com.badwei.pojo.User">-->
<!--        <property name="name" value="岩弟弟"/>-->
<!--    </bean>-->

<!--有参构造的3种实现方式（用的是有参构造器赋值，没有使用set）-->

<!--    第一种：下标赋值-->
<!--    <bean id="user" class="com.badwei.pojo.User">-->
<!--        <constructor-arg index="0" value="岩弟弟1" />-->
<!--    </bean>-->

<!--    第二种：通过类型创建对象，不建议使用（多个参数，无法统一类型）-->
<!--    <bean id="user" class="com.badwei.pojo.User">-->
<!--        <constructor-arg type="java.lang.String" value="岩弟弟2" />-->
<!--    </bean>-->

<!--    第三种：name指参数名（最常用）-->
    <bean id="user" class="com.badwei.pojo.User">
        <constructor-arg name="name" value="岩弟弟3" />
    </bean>

    <bean id="userT" class="com.badwei.pojo.UserT">

    </bean>


</beans>

继续创建另一个pojo类

UserT.java

package com.badwei.pojo;

public class UserT {
    private String name;

    public UserT(){
        System.out.println("UserT的无参构造");
    }
}

测试：

import com.badwei.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
//        User user = new User();

        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user");
        User user2 = (User) context.getBean("user");

        System.out.println(user);
        System.out.println(user2);

        System.out.println(user == user2);//true

    }
}

测试结果

4.3、结论：

在配置文件加载的时候。其中管理的对象都已经初始化了！

5、Spring配置

5.1、别名

（一般不用，5.2中的name也可以做别名使用）

<!--第三种：name指参数名-->
<bean id="user" class="com.badwei.pojo.User">
    <constructor-arg name="name" value="岩弟弟3" />
</bean>
<!--别名，如果添加了别名，我们也可以使用别名获取对象-->
<alias name="user" alias="userNew" />

测试

public class MyTest {
    public static void main(String[] args) {
//        User user = new User();

        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("userNew");//可以通过别名获取对象
        User user2 = (User) context.getBean("user");//仍然可以使用原来的名字获取对象

        System.out.println(user);
        System.out.println(user2);

        System.out.println(user == user2);//true,别名和本名获取的是同一个对象

    }
}

5.2、Bean的配置

<!--
    id : bean的唯一标识符，也就是相当于我们学的对象名
    class : bean对象所对应的全限定名：包名 + 类型
    name : 也是别名，而且name可以取多个别名(类似逗号，空格，分号都可以做分隔符，一般用逗号)
-->
<bean id="userT" class="com.badwei.pojo.UserT" name="userT2 U2,userT3;U4">

</bean>

测试：

public class MyTest {
    public static void main(String[] args) {

        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserT user = (UserT) context.getBean("userT2");
        UserT user2 = (UserT) context.getBean("U2");
        UserT user3 = (UserT) context.getBean("userT3");
        UserT user4 = (UserT) context.getBean("U4");

        System.out.println(user);
        System.out.println(user2);
        System.out.println(user3);
        System.out.println(user4);

        System.out.println(user == user2);//true
        System.out.println(user == user3);//true
        System.out.println(user == user4);//true都是同一个对象

    }
}

5.3、import

import一般用于团队合作开发,导入其他配置文件，合并为一个配置文件，

<import resource="beans.xml"/>

6、依赖注入

6.1、构造器注入

前面4已经讲了

6.2、Set方式注入【重点】

依赖注入：本质Set注入
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中的所有属性，由容器来注入

【环境搭建】

复杂类型
真实测试对象

1.Address.java

package com.badwei.pojo;

public class Address {
    private String address;

    //set(),get(),toString()
}

2.Student.java

package com.badwei.pojo;

import java.util.*;

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;

    //get(),set(),toString()
}

3.application.xml

<bean id="student" class="com.badwei.pojo.Student">
    <property name="name" value="岩弟弟" />
</bean>

4.测试类

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

set注入

1.普通值注入 2.Bean注入 3.array数组注入 4.List 5.Map 6.Set 7.null 8.Properties

<?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
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="address" class="com.badwei.pojo.Address" >
        <property name="address" value="北京" />
    </bean>

    <bean id="student" class="com.badwei.pojo.Student">
<!--1.普通值注入-->
        <property name="name" value="岩弟弟" />
<!--2.Bean注入-->
        <property name="address" ref="address" />
<!--3.array数组注入-->
        <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>
<!--5.Map-->
        <property name="card">
            <map>
                <entry key="校园卡" value="1112435153" />
                <entry key="银行卡" value="1454648613" />
            </map>
        </property>
<!--6.Set-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>CS</value>
                <value>DNS</value>
            </set>
        </property>
<!--7.null-->
        <property name="wife">
            <null/>
        </property>
<!--8.Properties-->
        <property name="info">
            <props>
                <prop key="学号">18110506127</prop>
                <prop key="username">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>

    </bean>

</beans>

6.3、拓展方式注入

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

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

User.java

package com.badwei.pojo;

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

    //无参，有参，get,set,toString
}

userbeans.xml

p命名空间注入

本质：set ,property

<!-- p命名空间注入，可以直接注入属性的值set：property -->
<bean id="user" class="com.badwei.pojo.User" p:name="岩弟弟p" p:age="15" />

c命名空间注入

本质：有参构造器，construct-args

如果只提供一个参数的话，需要实体类User提供一个参数的构造器

<!-- c命名空间注入，通过构造器注入：construct-args -->
<bean id="user2" class="com.badwei.pojo.User" c:age="18" c:name="老李"/>

6.4、Bean的作用域

1.单例模式（Spring默认模式，无需设置）

<bean id="user2" class="com.badwei.pojo.User" c:age="18" c:name="老李" scope="singleton"/>

2.原型模式，每次从容器中get的时候，都会产生一个新对象

 <bean id="user2" class="com.badwei.pojo.User" c:age="18" c:name="老李" scope="prototype"/>

测试

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

7.Bean的自动装配

自动装配是使用spring满足bean依赖的一种方法
spring会在应用上下文中为某个bean寻找其依赖的bean。

Spring中bean有三种装配机制，分别是：

在xml中显式配置；
在java中显式配置；
隐式的bean发现机制和自动装配。【重要】

7.1、环境搭建

Cat.java

package com.badwei.pojo;

public class Cat {
    public void shout(){
        System.out.println("喵~");
    }
}

Dog.java

package com.badwei.pojo;

public class Dog {
    public void shout(){
        System.out.println("汪~");
    }
}

Person.java

package com.badwei.pojo;

public class Person {
    private Dog dog;
    private Cat cat;
    private String name;

    //get,set,toString
}

beans.xml

<bean id="dog" class="com.badwei.pojo.Dog"/>

<bean id="cat" class="com.badwei.pojo.Cat" />

<bean id="person" class="com.badwei.pojo.Person" >
    <property name="name" value="岩弟弟" />
    <property name="dog" ref="dog" />
    <property name="cat" ref="cat" />
</bean>

测试类

@Test
public void test1(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    Person person = (Person) context.getBean("person");
    System.out.println(person);
    person.getDog().shout();
    person.getCat().shout();
}

7.2、byName自动装配

当一个bean节点带有 autowire ="byName"的属性时。

将查找其类中所有的set方法名，例如setCat，获得将set去掉并且首字母小写的字符串，即cat。
去spring容器中寻找是否有此字符串名称id的对象。
如果有，就取出注入；如果没有，就报空指针异常。

<bean id="dog" class="com.badwei.pojo.Dog"/>

<bean id="cat" class="com.badwei.pojo.Cat" />

<bean id="person" class="com.badwei.pojo.Person" autowire="byName">
    <property name="name" value="岩弟弟" />
</bean>

7.3、byType自动装配

使用autowire byType首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一的异常。

1、使用autowire="byType"

<bean id="dog11" class="com.badwei.pojo.Dog"/>

<bean id="cat11" class="com.badwei.pojo.Cat" />
<!--不需要管名字，只匹配类型Type-->
<bean id="person" class="com.badwei.pojo.Person" autowire="byType">
    <property name="name" value="岩弟弟" />
</bean>

2、测试，输出正常

3、再注册一个cat 的bean对象！

<bean id="dog11" class="com.badwei.pojo.Dog"/>

<bean id="cat11" class="com.badwei.pojo.Cat" />
<bean id="cat22" class="com.badwei.pojo.Cat" />
<!--不需要管名字，只匹配类型Type-->
<bean id="person" class="com.badwei.pojo.Person" autowire="byType">
    <property name="name" value="岩弟弟" />
</bean>

4、测试，报错：NoUniqueBeanDefinitionException

5、删掉cat22，将cat的bean名称改掉！测试！因为是按类型装配，所以并不会报异常，也不影响最后的结果。甚至将id属性去掉，也不影响结果。

小结：

byName: 需要保证所有的bean的id唯一，并且这个bean需要和自动注入的属性的set的方法的值一致！
byType: 需要保证所有的bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！

7.4、使用注解实现自动装配

jdk1.5支持注解，spring2.5支持注解

要使用注解须知：

1.导入约束context约束

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

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

<context:annotation-config/>

<?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>

@Autowired （最常用）

@Autowired是自动注入，默认首先按照类型（byType）注入，如果只有一个类型bean则成功，如果是多个同类型bean则再按照名称（默认小写）注入，如果找到了则成功，否则失败。

直接在属性上使用即可，也可以在set方法上使用
@Autowired是根据类型自动装配的
使用**@Autowired **我们可以不用编写Set方法，前提是你这个自动装配的属性在IOC（Spring）容器中存在，且符合名字byName

科普：

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

public @interface Autowired {
    boolean required() default true;
}

//如果显示定义了Autowired的required=false,说明这个对象可以为null，否则不允许为空
@Autowired(required = false)

测试：

<!--名字不同依然可以自动装配，@Autowired是根据类型自动装配的-->
<bean id="dog222" class="com.badwei.pojo.Dog"/>
<bean id="cat222" class="com.badwei.pojo.Cat" />
<bean id="person" class="com.badwei.pojo.Person"/>

public class Person {
    private String name;
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
}

@Qualifier

@Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配
@Qualifier不能单独使用。

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

类型复杂：

<bean id="dog111" class="com.badwei.pojo.Dog"/>
<bean id="dog222" class="com.badwei.pojo.Dog"/>
<bean id="cat111" class="com.badwei.pojo.Cat" />
<bean id="cat222" class="com.badwei.pojo.Cat" />
<bean id="person" class="com.badwei.pojo.Person"/>

可以使用@Qualifier进行id匹配装配

@Autowired
@Qualifier(value = "cat111")//指定装配的是id="cat111"的bean
private Cat cat;

@Resource

@Autowired，默认byType

@Resource，默认按照id（byName）注入，

@Resource可以添加name属性，来匹配复杂bean

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

<bean id="cat111" class="com.badwei.pojo.Cat" />
<bean id="cat222" class="com.badwei.pojo.Cat" />

三者测试总结：

使用@Autowired进行自动注入

@Autowired
private Cat cat;

beans.xml

<!--只有一个Cat类型, 不在乎id, 注入成功-->
<bean id="cat111" class="com.badwei.pojo.Cat" />

<!--多个Cat类型, 根据默认cat寻找, 找到第一个, 注入成功-->
<bean id="cat" class="com.badwei.pojo.Cat" />
<bean id="cat111" class="com.badwei.pojo.Cat" />

<!--多个Cat类型, 根据默认cat寻找, 没有找到"cat", 注入失败-->
<bean id="cat111" class="com.badwei.pojo.Cat" />
<bean id="cat222" class="com.badwei.pojo.Cat" />

此时需要设置@Qualifier，来单独指定id，注入成功

@Autowired
@Qualifier(value = "cat111")
private Cat cat;

也可以直接使用@Resource和name属性指定，注入成功

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

总结：

@Autowired默认byType，仅一个bean对象，与id无关，多个bean对象，寻默认id，寻到，注入成功，否则失败。无法注入多个无默认id的bean对象，需要借助@Qualifier指定id

@Resource默认byName, 无默认name时，通过类型寻找，只有一个bean，匹配成功，否则失败，可以设置name属性指定id, 进行注入

小结

@Autowired与@Resource异同：

@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。
@Autowired默认按byType类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用
@Resource（属于J2EE复返），默认按照byName名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

8、使用注解开发

8.1、bean配置

在spring4之后，想要使用注解形式，必须得要引入aop的包

在配置文件当中，还得要引入一个context约束,增加注解的支持

<?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"
       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/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--指定要扫描的包，这个包下的注解就会生效-->
	<context:component-scan base-package="com.badwei.pojo" />
    <!--启用注解-->
    <context:annotation-config/>

8.2、属性如何注入

//等价于<bean id="user" class="com.badwei.pojo.User" />
@Component
public class User {
//    @Value("岩嗷嗷")//相当于<property name="name" value="岩嗷嗷" />
    public String name;

    @Value("岩嗷嗷")
    public void setName(String name) {
        this.name = name;
    }
}

8.3、衍生的注解

@Component有几个衍生的注解，我们在web开发中，会按照mvc三层架构分层

dao【@Repository】
service【@Service】
controller【@Controller】

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

8.4、自动装配置

@Autowired：自动装配通过1.类型，2名字。

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

8.5、作用域

@Scope("singleton")//单例
//@Scope("prototype")//原型模式
public class User {
}

8.6小结

xml与注解

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

xml与注解最佳实践

xml用例管理bean
注解只负责完成属性的注入
我们在使用的过程中，只需要注意一个问题，一定要开启注解支持

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

9、使用java的方式配置Spring

我们现在要完全不使用spring的xml配置，全权交给java来做。

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

实体类User.java

//说明这个类被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 + '\'' +'}';}
}

配置类BadweiConfig2.java（为了上面BadweiConfig的@Import而创建使用）

@Configuration
public class BadweiConfig2 {
}

配置类BadweiConfig.java

//这个也会背Spring容器托管，被注册到容器中，他本来就是一个@Component
//@Configuration 代表这是一个配置类，就和我们之前看的beans.xml
@Configuration
@ComponentScan("com.badwei.pojo")
@Import(BadweiConfig2.class)
public class BadweiConfig {

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

测试类MyTest

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

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

10、代理模式

代理模式：

静态代理
动态代理

10.1、静态代理

10.1-1、角色分析：

抽象角色 : 一般使用接口或者抽象类来实现
真实角色 : 被代理的角色
代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作
客户 : 使用代理角色来进行一些操作

10.1-2、代码步骤：

1.接口

//租房
public interface Rent {
    public void rent();
}

2.真实角色

//房东
public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

3.代理角色

public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }


    public void seeHouse(){
        System.out.println("中介看房");
    }
    public void hetong(){
        System.out.println("中介签合同");
    }
    public void fare(){
        System.out.println("收中介费");
    }

    @Override
    public void rent() {
        host.rent();
    }
}

4.客户端访问代理角色

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮房东租房子，并带有附属操作
        Proxy proxy = new Proxy(host);
        //不用面对房东，直接找中介租房即可
        proxy.rent();
    }
}

10.1-3、代理模式的优缺点

代理模式的好处：

可以使真实角色的操作更加纯粹
公共业务就交给代理角色，实现了业务的分工
公共业务发生拓展的时候，方便管理

缺点：

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

10.2、静态代理的加深理解

10.2-1、实现User增删改查实现类的代理

创建一个抽象类

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

2.需要一个真实对象类完成这个操作，实现类

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 query() {
        System.out.println("查询一个用户");
    }
}

3.需求，每个操作增加一个日志

思路一：在实现类上增加代码【麻烦，不易于维护】
思路二：使用代理类来做，不需要改变原先业务

4.设置一个代理类来处理日志，代理角色

public class UserServiceProxy implements UserService{

    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService){
        this.userService = userService;
    }

    @Override
    public void add() {
        log("add");
        userService.add();
    }

    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void query() {
        log("query");
        userService.query();
    }

    public void log(String msg){
        System.out.println("使用了代理日志：" + msg + "方法开启****");
    }
}

测试：

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
//        userService.add();//之前未使用代理
        UserServiceProxy userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserService(userService);

        userServiceProxy.add();
    }
}

10.2-2、总结：

理解其中的思想；我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想

10.2-3、AOP：纵向开发,横向开发

10.3、动态代理

10.3-1、介绍

动态代理和静态代理角色一样
动态代理的代理是动态生成的，不是我们直接写好的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口---JDK 动态代理
- 基于类---cglib
- 基于字节码---javassist

10.3-2、需要了解：Proxy， InvocationHandler

【InvocationHandler：调用处理程序】

Object invoke(Object proxy, 方法 method, Object[] args)；
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。

【Proxy : 代理】

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

10.3-3、代码实现：

Rent.java接口

public interface Rent {
    public void rent();
}

Host.java

//房东
public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

ProxyInvocationHandler.java

package com.badwei.demo03;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//用这个类，自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Rent rent;

    public void setRent(Rent rent){
        this.rent = rent;
    }

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

    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //动态代理的本质，就是使用反射机制实现
        seeHouse();
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }

    public void seeHouse(){
        System.out.println("中介看房子");
    }
    public void fare(){
        System.out.println("中介收中介费");
    }

}

Client测试

package com.badwei.demo03;

public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();

        //代理角色：现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象
        pih.setRent(host);

        Rent proxy = (Rent) pih.getProxy();//这里的proxy就是动态生成的，我们并没写

        proxy.rent();
    }
}

10.3-4、通用代理工具类

package com.badwei.demo04;

import com.badwei.demo03.Rent;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//用这个类，自动生成代理类
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);
    }

    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //动态代理的本质，就是使用反射机制实现
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    //新增的代理log()方法
    public void log(String msg){
        System.out.println("log日志：执行了：" + msg + "方法");
    }

}

测试：

package com.badwei.demo04;

import com.badwei.demo02.UserService;
import com.badwei.demo02.UserServiceImpl;

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色，不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();//

        pih.setTarget(userService);//设置要代理的对象

        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();

        proxy.add();
        proxy.delete();

    }
}

10.3-5、动态代理的好处：

包含静态代理的好处

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

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

公共业务发生拓展的时候，方便管理

一个动态代理类代理的是一个接口，一般就是对应一个业务
一个动态代理类可以代理多个类，只要是实现了同一个接口即可

11.AOP

11.1、什么是AOP

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

11.2、AOP在Spring中的作用

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

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

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

11.3、使用Spring实现AOP

方式一：使用Spring的接口【主要是SpringAPI接口实现】

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

方式三：使用注解实现

【重点】使用AOP织入，需要导入一个依赖包！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
    <scope>runtime</scope>
</dependency>

方式一：使用Spring的接口【主要是SpringAPI接口实现】

UserService.java

package com.badwei.service;

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

UserServiceImpl.java

package com.badwei.service;

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("查询了一个用户");
    }
}

Log.java

package com.badwei.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {

    //method: 要执行的目标对象的方法
    //args: 参数
    //o: 目标对象
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName() + "的" + method.getName() + "被执行了");
    }
}

AfterLog.java

package com.badwei.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {

    //o,返回值
    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("执行了" + method.getName() + "方法，返回结果为：" + o);

    }
}

applicationContext.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
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="com.badwei.service.UserServiceImpl" />
    <bean id="log" class="com.badwei.log.Log" />
    <bean id="afterLog" class="com.badwei.log.AfterLog" />

<!--    方式一：使用原生Spring API接口-->
<!--    配置aop：需要导入aop约束-->
    <aop:config>
<!--        切入点：expression：表达式，execution(要执行的位置！* * * * *)-->
        <aop:pointcut id="pointcut" expression="execution(* com.badwei.service.UserServiceImpl.*(..))"/>

<!--        执行环绕增强-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut" />
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut" />

    </aop:config>

</beans>

MyTest测试

import com.badwei.service.UserService;
import com.badwei.service.UserServiceImpl;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

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

DiyPointCut.java

package com.badwei.diy;

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

applicationContext.xml

<!--方式二：自定义类-->
<bean id="diy" class="com.badwei.diy.DiyPointCut" />

<aop:config>
    <aop:aspect ref="diy">
        <!--切入点-->
        <aop:pointcut id="point" expression="execution(* com.badwei.service.UserServiceImpl.*(..))" />
        <!--通知-->
        <aop:before method="before" pointcut-ref="point" />
        <aop:after method="after" pointcut-ref="point" />
    </aop:aspect>
</aop:config>

测试类与方法一相同

方式三：使用注解实现AOP

package com.badwei.diy;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

//方式三：使用注解实现AOP
@Aspect //标注这个类是一个切面
public class AnnotationPointCut {

    @Before("execution(* com.badwei.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("方法执行前");
    }

    @After("execution(* com.badwei.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("方法执行后");
    }

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

在 applicationContext.xml 中注册bean，并增加支持注解的配置

<!--方式三-->
<bean id="annotationPointCut" class="com.badwei.diy.AnnotationPointCut" />
<!--开启注解支持-->
<aop:aspectj-autoproxy />

测试代码MyTest不变

测试结果

12、整合Mybatis

参考mybatis-spring的官方文档

http://mybatis.org/spring/zh/index.html

步骤：

1.导入相关jar包

Junit
mybatis
mysql
spring
aop
mybatis-spring【new】

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.49</version>
</dependency>

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.7</version>
</dependency>


<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.9</version>
</dependency>

<!--这里的spring-webmvc和spring-jdbc版本要一致，否则会报错-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.9</version>
</dependency>

<!--事务必须要导的包-->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.6</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>RELEASE</version>
    <scope>compile</scope>
</dependency>

2.编写配置文件

3.测试

12.1、回忆mybatis

1.编写实体类

package com.badwei.pojo;

import lombok.Data;

@Data
public class User {
    private int id;  //id
    private String name;   //姓名
    private String pwd;   //密码
}

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.badwei.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/lxw002?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

<!--        每一个Mapper.xml都需要在mybatis中注册-->
    <mappers>
        <mapper class="com.badwei.mapper.UserMapper"/>
    </mappers>

</configuration>

3.编写接口

package com.badwei.mapper;

import com.badwei.pojo.User;

import java.util.List;

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

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.badwei.mapper.UserMapper">

    <select id="selectUser" resultType="user">
        select * from user
    </select>

</mapper>

5.测试

import com.badwei.mapper.UserMapper;
import com.badwei.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import org.apache.ibatis.io.Resources;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MyTest {
    @Test
    public void test1() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sessionFactory.openSession(true);
		//之前都用工具类，上面这些都忘记了。。。
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.selectUser();
        for (User user : users) {
            System.out.println(user);
        }

        sqlSession.close();

    }
}

12.2、Mybatis-spring

1.User.java【不变】

2.UserMapper.java【不变】

3.UserMapper.xml【不变】

4.新增UserMapperImpl.java

package com.badwei.mapper;

import com.badwei.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

public class UserMapperImpl implements UserMapper{

    //我们的所有操作都是用sqlSession来执行，在原来，现在都是用sqlSessionTemplate;

    private SqlSessionTemplate sqlSession;

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

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

5.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.badwei.pojo"/>
    </typeAliases>

</configuration>

6.spring-dao.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
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

<!--DataSource:使用Spring的数据源替换Mybatis的配置C3p0 dbcp druid
我们这里使用了Spring提供的JDBC：org.springframework.jdbc.datasource-->
    <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/lxw002?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8" />
        <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="mapperLocations" value="classpath*:com/badwei/mapper/*.xml" />
    </bean>

    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate" >
        <constructor-arg index="0" ref="sqlSessionFactory" />
    </bean>


</beans>

7.applicationContext.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
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <import resource="spring-dao.xml" />


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

</beans>

8.测试

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

    }
}

新：SqlSessionDaoSupport

继承SqlSessionDaoSupport

UserMapperImpl2.java

package com.badwei.mapper;

import com.badwei.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
    @Override
    public List<User> selectUser() {
        return getSqlSession().getMapper(UserMapper.class).selectUser();
    }
}

applicationContext.xml中注册bean

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

测试正常查询

遇到的问题：

报错：报classnofoundexception的可以看看springframework的版本，spring-jdbc和spring-webmvc的版本要一致

13、声明式事务

13.1、回顾事务

把一组业务当成一个业务来做；要么都成功，要么都失败
事务在项目中，十分的重要，涉及到数据的一致性问题，不能马虎
确保完整性和一致性

事务的ACID原则

原子性
一致性
隔离性
- 多个业务可能操作同一个资源，防止数据损坏
持久性
- 事务一旦提交成功，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中

13.2、spring中的事务管理

声明式事务：AOP
编程式事务：需要在代码中进行事务的管理

为什么需要事务：

如果不配置事务，可能存在数据提交不一致的情况
如果我们不在spring中去配置声明式事务，我们就需要在代码中手动配置事务
事务在项目的开发中十分重要，涉及到数据的一致性和完整性

13.3、代码测试事务：

目标：

测试事务存在的必要。

在一个方法（一组业务）中同时具有增加add和删除delete功能, 手动修改delete的sql语句，使得delete会报错，然后执行这个方法（这组业务），发现增加add成功，删除delete失败，不符合需求。

使用spring声明式事务后，再次执行这个方法（这组业务），发现增加add和删除delete均失败，符合事务。

1.User【不变】

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;  //id
    private String name;   //姓名
    private String pwd;   //密码
}