Spring

Lazy龙

于 2022-12-27 12:19:43 发布

阅读量247

点赞数

分类专栏： Java 文章标签： spring java 前端

本文链接：https://blog.csdn.net/qq_48512649/article/details/128309307

版权

Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Spring

引出框架

开闭原则OCP

*OCP是软件七大开发原则当中最基本的一个原则：开闭原则——O_open C_close

对什么开？对扩展开放。

对什么闭？对修改关闭。

*OCP原则是最核心的、最基本的，其他的六个原则都是为这个原则服务的。

*OCP开闭原则的核心是什么？

只要你在扩展系统功能的时候，没有修改以前写好的代码，那么符合OCP原则

反之，如果在扩展系统功能的时候修改了之前的代码，那么这个设计是失败的，违背OCP原则

*当进行系统功能扩展的时候，如果动了之前稳定的程序，修改了之前的程序，之前所有程序都需要重新测试。这是不想看到的，因为非常麻烦。

依赖倒置原则（DIP原则）

*什么是依赖倒置原则？

面向接口编程，面向抽象编程，不要面向具体编程。

*目的

降低程序耦合度，提高扩力

*什么叫做符合依赖倒置原则？

“上“不依赖”下“，就符合

*什么叫做违背依赖倒置原则？

上依赖下，就是违背

只要“下”一改动，“上”就受到牵连

在这里插入图片描述

UserAction依赖了具体的UserServiceImpl
UserServiceImpl依赖了具体的UserDaoImplForMySQL
目前来说：上是依赖下的
凡是上依赖下的都违背了依赖倒置原则
什么叫做符合依赖倒置原则？什么叫遵守依赖倒置原则
上不再依赖下了，表示符合依赖倒置原则。

依赖倒置原则的核心是什么？

倡导面向接口编程，面向抽象编程，不要面向具体编程。

控制反转IoC理论推导

当前程序的设计，显然既违背OCP又违背DIP，怎么办？

可以采用”控制反转“这种编程思想。来解决这个问题

什么是控制反转？

控制反转：IoC（Inversion of Control）

反转是什么呢？

反转的是两件事：

第一件事：我不在程序中采用硬编码的方式来new对象了。（new对象的权力交出去了。）

第二件事：我不在程序中采用硬编码的方式来维护对象关系了。（对象之间关系的维护权也交出去了。）

控制反转是一种编程思想，或者叫做一种新型的设计模式，由于出现的比较新，没有纳入GoF23种设计模式范围内。

依赖注入

spring框架实现了控制反转IoC这种思想的一种框架

Spring框架可以帮你new对象

Spring框架可以帮你维护维护对象和对象之间的关系。

*Spring是一个实现了IoC思想的容器。

*控制反转的实现方式有多种，其中比较重要的叫做：依赖注入（Dependency Injection，简称DI）。

*控制反转是思想，依赖注入是控制反转思想的一种实现方式。

依赖注入DI，又包括常见的两种方式：

第一种：set注入（执行set方法给属性赋值）

//利用set进行动态实现值的注入
public void setUserDao(UserDao userDao){
    this.userDao = userDao;
}
//之前程序是主动创建对象，控制权在程序员手上
//使用了set注入之后，程序不在具有主动性，而是变成了被动接收对象

第二种：构造方法注入（执行构造方法给属性赋值）——使用构造方法通过反射机制创建对象

*依赖注入中的依赖是什么意思？注入又是什么意思？

依赖：A对象和B对象的关系。

注入：是一种手段，通过这个手段使A对象和B对象产生关系。

依赖注入：对象A和对象B之间的关系，靠注入的手段来维护，而注入包括set注入和构造注入

总结术语

OCP：开闭原则（开发原则）

DIP：依赖倒置原则（开发原则）

IoC：控制反转（一种思想，一种新型的设计模式）

DI：依赖注入（控制反转思想的具体实现方式）

概述

优点

Spring是一个开源的免费的框架（容器）！
Spring是一个轻量级的、非入侵式的框架！
Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。
Spring是为简化开发而生，让程序员只需要关注核心业务的实现，尽可能的不在关注非业务逻辑代码（事务控制，安全日志、对框架整合的支持）。

总结：Spring就是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的框架

Spring boot
- 一个快速开发的脚手架
- 基于Springboot可以快速开发单个微服务
- 约定大于配置
Spring Cloud
- Spring Cloud是基于SpringBoot实现的

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

Spring弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称：“ 配置地狱！”

Spring八大模块

Spring Core : 控制反转（IoC）

Spring Aop ：面向切面编程

Spring Web MVC ： Spring自己提供了一套MVC框架

Spring DAO ：提供了单独的支持JDBC操作的API

Spring Webflux : Spring提供的响应式Web框架

Spring Web ：集成常见的Web框架

Spring ORM ：集成常见的ORM框架

Spring Context ： Spring上下文

什么是侵入性设计？

假设我开发了一个框架，这个框架中有一个类，类中有一个方法，该方法上有一个参数HttpServlet

//框架中的某一个类,此类运行Http依赖于tomcat，属于侵入式设计——不好做单元测试
public class MyClass{
    public void doSome(HttpServlet servlet){
        
    }
    public void aoOther(HttpServletRequest request){
        
    }
}

Bean

每一个被Spring框架管理的对象叫做Bean

放Bean的器皿叫做容器，——Spring容器

Spring配置

配置pom.xml

 <!--打包方式jar，项目可以不是web项目，普通的Java项目即可 -->
    <packaging>jar</packaging>
<!--配置多个版本的仓库    -->
    <repositories>
<!--spring里程碑版本的仓库-->
        <repository>
            <id>repository.spring.milestone</id>
            <name>Spring Milestone Repository</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>
    <!--依赖    -->
    <dependencies>
<!--spring context-->
<!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入-->
<!--如果想要使用Spring的JDBC，或者说其他的事务的tx，那么还需要再次添加依赖-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>6.0.0-M2</version>
            </dependency>
<!--junit依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

配置Bean

<!--这是Spring的配置文件-->
<!--    IDEA为我们提供了这个文件的模板-->
<!--    文件名自己起-->
<!--    这个文件最好放在类路径当中，方便后期移植-->
<!--    放在resources根目录下，就相当于是放到了类的根目录下-->
<!--    配置bean，这样Spring才可以帮助我们管理对象-->
<!--
        bean标签的两个重要属性，id：是bean的身份证号，是唯一的标识——等价于new对象的变量名
        class：必须填写类的全路径，全限定类名（带包名的类名）
    id = 变量名
    class = new 的对象
    property = 给对象中的属性设置一个值
        property中value用来给普通字段赋值，ref用来引用Spring已经创建好的bean对象
        -->
    <bean id="userBean" class="com.powernode.spring6.bean.User">
       <property name="str" value="String"/>
    </bean>
<!--    配置其他的bean-->
    <bean id="userDaoBean" class="com.powernode.spring6.dao.UserDaoImplForMySQL">

    </bean>
<!--    配置Java.util.Date Bean-->
    <bean id="nowTime" class="java.util.Date">

    </bean>

通过有参构造编写配置文件创建对象

1、UserT . java

public class UserT {

   private String name;

   public UserT(String name) {
       this.name = name;
  }

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

   public void show(){
       System.out.println("name="+ name );
  }

}
2、beans.xml 有三种方式编写

<!-- 第一种根据index参数下标设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <!-- index指构造方法,下标表示有参构造的属性 下标从0开始 -->
   <constructor-arg index="0" value="kuangshen2"/>
</bean>
    
<!-- 第二种根据参数名字设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <!-- name指参数名 -->
   <constructor-arg name="name" value="kuangshen2"/>
</bean>
    
<!-- 第三种根据参数类型设置，type为参数类型，引用类型必须写全路径，不建议使用 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <constructor-arg type="java.lang.String" value="kuangshen2"/>
</bean>

第一个Spring程序

public class FirstSpringTest {
    @Test
    public void testFirstSpringCode(){
        //1.获取Spring容器对象
        //ApplicationContext 翻译为：应用上下文，其实就是Spring容器
        //ApplicationContext 是一个接口
        //ApplicationContext 接口下有很多实现类，其中有个实现类为：ClassPathXmlApplicationContext
        //ClassPathXmlApplicationContext  专门从类路径当中加载Spring配置文件的一个Spring上下文对象
        //注意：不是调用getBean方法的时候创建对象，执行ClassPathXmlApplicationContext的时候，就会实例化对象
        //从类的根路径下开始找——resources
        //只要一执行，相当于启动Spring容器，并且解析Spring的XML文件，并且把xml文件中的bean对象全部new出来，放到Spring容器里边
        //底层通过反射机制调用无参构造方法创建对象
        //创建好的对象底层储存在Map里边————key为Bean的id   value为Bean的对象
        ApplicationContext   applicationContext = new ClassPathXmlApplicationContext("spring.xml","bean.xml","XML/vip.xml");//spring配置文件的路径，参数类型为可变长参数，可以写多个配置文件


        //2.根据Bean的id从Spring容器中获取这个对象
        //返回对象为Object类型
        //获取Bean的id不存在，不会返回null而是会出现异常
        Object userBean = applicationContext.getBean("userBean");
        System.out.println(userBean);
        Object userDaoBean = applicationContext.getBean("userDaoBean");
        //获取系统当前时间——Object强制类型转换为Date
        Date nowTime1 = (Date) applicationContext.getBean("nowTime");
        //日期格式化
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String strNowTime = sdf.format(nowTime1);
        System.out.println(strNowTime);
        //不想强制类型转换可以使用如下代码（通过getBean的第二个参数来指定返回的Bean的类型）
        Date nowTime2 = applicationContext.getBean("nowTime",Date.class);
        //类型转换之后调用本类方法
        UserDaoImplForMySQL userDaoBean2 = applicationContext.getBean("userBean", UserDaoImplForMySQL.class);
        userDaoBean2.insert();

    }

    @Test
    public void testXmlPath(){
        //在D盘加载xml文件路径
        //FileSystemXmlApplicationContext不是在类路径当中加载资源——很少用
        ApplicationContext applicationContext = new FileSystemXmlApplicationContext("d:/spring6.xml");
    }

    @Test
    public void testBeanFactory(){
        //ApplicationContext接口的超级父接口是：BeanFactory（翻译为Bean工厂，能够生产Bean对象的一个工厂对象）
        //BeanFactory是IoC容器的顶级接口
        //Spring的IoC容器底层实际上使用了工厂模式
        //Spring底层的IoC是怎样实现的？XML解析 + 工厂模式 + 反射机制
        BeanFactory applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        User user = applicationContext.getBean("userBean", User.class);
        System.out.println(user);
    }
}

public class User {
    //Spring是怎么实例化对象的？
    //默认情况下Spring会通过反射机制调用类的无参构造方法来实例化对象——》所以要保证无参构造方法存在
    //实现原理如下：
    //Class c1 = Class.forName("edu.cn.neusoft.project.test.A");//获得Class对象
    //A a1 = (A) c1.newInstance();//本质是调用了类的无参构造器   如果没有无参构造则报错
    public User() {
    }
}

其他xml配置

别名

alias 设置别名 , 为bean设置别名 , 可以设置多个别名
<!--设置别名：在获取Bean的时候可以使用别名获取,相当于给bean的id另赋一个值，效果相同-->
<alias name="userT" alias="userNew"/>

bean的配置

<!--bean就是java对象,由Spring创建和管理-->

<!--
   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
   如果配置id,又配置了name,那么name是别名
   name可以设置多个别名,可以用逗号,分号,空格隔开
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;

class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

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

<import resource="{path}/beans.xml"/>
    
    //例:当有多个xml文件时，在总的xml文件使用import可以将多个合并为一个
    <import resource="bean1.xml"/>
    <import resource="bean2.xml"/>
    <import resource="bean3.xml"/>
    //使用的时候直接使用总的配置文件就可以了
    ApplicationContext   applicationContext = new ClassPathXmlApplicationContext("总配置文件.xml");

依赖注入

构造器注入

set注入

依赖注入：set注入
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中的所有属性由容器来注入
Address类

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

Student类

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;

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

    public void setAddress(Address address) {
        this.address = address;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    public void show(){
        System.out.println("name="+ name
                + ",address="+ address.getAddress()
                + ",books="
        );
        for (String book:books){
            System.out.print("<<"+book+">>\t");
        }
        System.out.println("\n爱好:"+hobbys);

        System.out.println("card:"+card);

        System.out.println("games:"+games);

        System.out.println("wife:"+wife);

        System.out.println("info:"+info);

    }
}

各种属性的配置方式

<?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="addr" class="com.powernode.spring6.bean.Address">
        <property name="address" value="hangzhou"></property>
    </bean>
    <bean id="student" class="com.powernode.spring6.bean.Student">
        <!--常量注入-->
        <property name="name" value="HYL"/>
        <!--bean注入-->
        <property name="address" ref="addr"></property>
        <!--数组注入-->
        <property name="books">
            <array>
                <value>西游记</value>
                <value>红楼梦</value>
                <value>三国演义</value>
            </array>
        </property>
        <!--List注入-->
        <property name="hobbys">
            <list>
                <value>滑板</value>
                <value>听歌</value>
                <value>打游戏</value>
            </list>
        </property>
        <!--Map注入-->
        <property name="card">
            <map>
                <entry key="中国邮政" value="737822737"/>
                <entry key="建行" value="14394822737"/>
            </map>
        </property>
        <!--set注入-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>BOB</value>
                <value>HYL</value>
            </set>
        </property>
        <!--null注入-->
        <property name="wife"><null /></property>
        <!--properties注入-->
        <property name="info">
            <props>
                <prop key="学号">212080</prop>
                <prop key="性别">男</prop>
                <prop key="姓名">HYL</prop>
            </props>
        </property>
    </bean>

</beans>

测试

@Test
    public void testBeanXML(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        Student stu = context.getBean("student", Student.class);
        stu.show();
    }
_______________________________________________________________________________________________
name=HYL,address=hangzhou,books=
<<西游记>>	<<红楼梦>>	<<三国演义>>	
爱好:[滑板, 听歌, 打游戏]
card:{中国邮政=737822737, 建行=14394822737}
games:[LOL, BOB, HYL]
wife:null
info:{姓名=HYL, 学号=212080, 性别=男}

进程已结束,退出代码

拓展方式注入

需要在头文件中加入约束文件

P命名注入：xmlns:p=“http://www.springframework.org/schema/p”

<!--P(属性: properties)命名空间 , 属性依然要设置set方法.相当于propertyies的另一种写法-->
    <bean id="userBean" class="com.powernode.spring6.bean.User" p:name="HYL" p:age="18">
    </bean>

C命名注入：xmlns:c=“http://www.springframework.org/schema/c”

<!--C(构造: Constructor)命名空间 , 属性依然要设置set方法.相当于有参构造方法注入-->
    <bean id="userBean1" class="com.powernode.spring6.bean.User" c:name="FWL" c:age="18">
    </bean>

User类

public class User {
    //Spring是怎么实例化对象的？
    //默认情况下Spring会通过反射机制调用类的无参构造方法来实例化对象——》所以要保证无参构造方法存在
    //实现原理如下：
    //Class c1 = Class.forName("edu.cn.neusoft.project.test.A");//获得Class对象
    //A a1 = (A) c1.newInstance();//本质是调用了类的无参构造器   如果没有无参构造则报错
    private String name;
    private int age;

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

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
————————————————————————————————————————————————————————————————————————————————————————————————————————
User{name='HYL', age=18}
User{name='FWL', age=18}

Bean的作用域

在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象 .

几种作用域中，request、session作用域仅在基于web的应用中使用（不必关心你所采用的是什么web应用框架），只能用在基于web的Spring ApplicationContext环境。

Singleton

当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。Singleton是单例类型，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象。注意，Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton，可以这样配置：

 <bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

测试：

 @Test
 public void test03(){
     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
     User user = (User) context.getBean("user");
     User user2 = (User) context.getBean("user");
     System.out.println(user==user2);
 }

Prototype

当一个bean的作用域为Prototype，表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。根据经验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。在XML中将bean定义成prototype，可以这样配置：

 <bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
  或者
 <bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

Request

当一个bean的作用域为Request，表示在一次HTTP请求中，一个bean定义对应一个实例；即每个HTTP请求都会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

 <bean id="loginAction" class=cn.csdn.LoginAction" scope="request"/>

针对每次HTTP请求，Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例，且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例的内部状态，而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。当处理请求结束，request作用域的bean实例将被销毁。

Session

当一个bean的作用域为Session，表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

 <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例，且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据userPreferences创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。

bean的自动装配

创建实体类

public class User {
    private Cat cat;
    private Dog dog;
    private String str;

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }
}
____________________________________________________________________________________
public class Dog {
    public void shout(){
        System.out.println("wang~");
    }
}
____________________________________________________________________________________
public class Cat {
    public void shout(){
        System.out.println("miao~");
    }
}

编写配置文件

    <bean id="dog" class="com.fwl.dao.Dog"/>
    <bean id="cat" class="com.fwl.dao.Cat"/>

    <!--autuwire="byName" :会自动在容器上下文中查找，和自己对象set方法后边的值对应的beanid    -->
    <!--autuwire="byType" :会自动在容器上下文中查找，和自己对象属性类型相同的bean——》必须保证类型全局唯一使用 -->
    <bean id="user" class="com.fwl.dao.User" autowire="byName">
        <property name="str" value="HYL"/>
    <!--autowire="byName"  实现效果与下两行代码相同 -->
<!--        <property name="cat" ref="cat"/>-->
<!--        <property name="dog" ref="dog"/>-->
    </bean>

小结：

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

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

NoUniqueBeanDefinitionException

bytype测试：

1、将user的bean配置修改一下： autowire=“byType”

2、测试，正常输出

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

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

<bean id="user" class="com.kuang.pojo.User" autowire="byType">
   <property name="str" value="qinjiang"/>
</bean>

测试结果报错

使用注解实现自动装配

jdk1.5开始支持注解，spring2.5开始全面支持注解。

准备工作：利用注解的方式注入属性。

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

    <!--开启注解的支持    -->
    <context:annotation-config/>
    <bean id="dog" class="com.fwl.dao.Dog"/>
    <bean id="cat" class="com.fwl.dao.Cat"/>
    <bean id="user" class="com.fwl.dao.User">
    </bean>
    
</beans>

User类====>使用@Autowired注解实现自动装配

public class User {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;

    private String str;
_____________________________________________________________________________
<bean id="dog" class="com.fwl.dao.Dog"/>
    <bean id="cat" class="com.fwl.dao.Cat"/>
    <bean id="user" class="com.fwl.dao.User">
        <property name="dog" ref="dog"/>   //相当于这两条配置
        <property name="cat" ref="cat"/> 
    </bean>

@Autowired注解

直接在属性上使用即可！也可以在set方法上使用

使用Autowired 我们可以不用编写Set方法，前提是你这个自动装配的属性在IoC（Spring）容器中存在，且符合名字byname

注：

@Autowired(required=false) 说明：false，对象可以为null；true，对象必须存对象，不能为null。

//@Autowired注解设置required默认为true，如果设置required = false允许对象为null，
@Autowired(required = false)
private Cat cat;

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

@Qualifier

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

测试实验步骤：

1、配置文件修改内容，保证类型存在对象。且名字不为类的默认名字！

<bean id="dog1" class="com.kuang.pojo.Dog"/>
<bean id="dog2" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

2、没有加Qualifier测试，直接报错

3、在属性上添加Qualifier注解

@Autowired
@Qualifier(value = "cat2")//value为bean的id值
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

**注：**如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成时，我们可以使用【@Qualifier(value = “cat2”)//value为bean的id值】去配合@Autowired使用，指定一个唯一的bean对象注入

@Resource

@Resource如有指定的name属性，先按该属性进行byName方式查找装配；
其次再进行默认的byName方式进行装配；
如果以上都不成功，则按byType的方式自动装配。
都不成功，则报异常。

实体类：

public class User {
   //如果允许对象为null，设置required = false,默认为true
   @Resource(name = "cat2")
   private Cat cat;
   @Resource
   private Dog dog;
   private String str;
}

beans.xml

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

<bean id="user" class="com.kuang.pojo.User"/>

测试：结果OK

配置文件2：beans.xml ，删掉cat2

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>

实体类上只保留注解

@Resource
private Cat cat;
@Resource
private Dog dog;

结果：OK

结论：先进行byName查找，失败；再进行byType查找，成功。

小结

@Autowired与@Resource异同

1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

2、@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用

3、@Resource（属于J2EE规范），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName；

@Component注解

属性注入

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

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

//@Component  英文——组件,等价于<bean id="user" class="com.fwl.moudle.User"/>
@Component
public class User {
    public String name = "FWL";
//@Component +  @Value 等价于<bean id="user" class="com.fwl.moudle.User"> <property name="nm" value="HYL"/> </bean>
    @Value("HYL")
    public String nm;
}

测试

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = context.getBean("user", User.class);
        System.out.println(user.name+"♥"+user.nm);
___________________________________________________________________________________
FWL♥HYL

@Component三个衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。

@Controller：web层
@Service：service层
@Repository：dao层

写上这些注解，就相当于将这个类交给Spring管理装配了

@Scope作用域

singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂，所有的对象都会销毁。
prototype：多例模式。关闭工厂，所有的对象不会销毁。内部的垃圾回收机制会回收

@Controller("user")
@Scope("prototype")
public class User {
   @Value("HYL")
   public String name;
}

XML与注解

XML与注解比较

XML可以适用任何场景，结构清晰，维护方便
注解不是自己提供的类使用不了，开发简单方便

xml与注解整合开发 ：推荐最佳实践

xml管理Bean
注解完成属性注入
使用过程中，可以不用扫描，扫描是为了类上的注解

<context:annotation-config/>

作用：

进行注解驱动注册，从而使注解生效
用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册
如果不扫描包，就需要手动配置bean
如果不加注解驱动，则注入的值为null

@Configuration注解

@Component

@Bean

@ComponentScan(“”)

@Import()

myConfig

//@Configuration —— 类似于<beans></beans>
//@Configuration  也会被Spring容器托管，注册到容器中，因为他本来就是一个@Component
@Configuration  //代表这是一个配置类，类似于beans.xml
@ComponentScan("com.fwl.moudle")// 扫描包下的类
@Import(fwlConfig.class)  //与xml文件import功能一致
public class myConfig {
    //作用是注册一个bean，相当于之前写的bean标签 —— 方法的名字相当于bean标签的id属性
    //方法的返回值相当于bean标签的class属性
    @Bean
    public User getUser(){
        return new User();  //返回要注入的bean对象
    }
}

User类

//这里 @Component 的意思，就是说明这个类被Spring接管了，注册到了容器中
@Component
public class User {

//@Component +  @Value 等价于<bean id="user" class="com.fwl.moudle.User"> <property name="nm" value="HYL"/> </bean>
    @Value("HYL")
    public String nm;

    private String string;

    public String getString() {
        return string;
    }
    //属性注入值
    @Value("FWL♥HYL")
    public void setString(String string) {
        this.string = string;
    }
    @Override
    public String toString() {
        return "User{" +
                ", nm='" + nm + '\'' +
                ", string='" + string + '\'' +
                '}';
    }
}

fwlConfig

@Configuration
public class fwlConfig {

}

Test

//如果完全使用了配置类方式去做，我们只能通过 AnnotationConfig 上下文来获取容器，通过配置类的class对象加载
        ApplicationContext context1 = new AnnotationConfigApplicationContext(myConfig.class);
        User user1 = (User) context1.getBean("getUser");
        System.out.println(user1.getString());

代理模式

SpringAOP的底层原理——代理模式

代理模式的分类：

静态代理
动态代理

在这里插入图片描述

静态代理（一）

角色分析：

抽象角色：一般会使用接口或抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，一般会做附属操作
客户：访问代理角色的人

代码步骤：

接口
真实角色
代理角色
客户端访问代理角色

//租房的接口
public interface Rent {
    //出租房屋
    public void rent();
}
____________________________________________________________________________________________
//房东
public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("房东出租房子");
    }
}
____________________________________________________________________________________________
//房屋中介
public class Proxy implements Rent{
    //房东
   private Host host;

    public Proxy() {
    }
    public Proxy(Host host) {
        this.host = host;
    }
    @Override
    public void rent() {  //出租房东的房子
        seeHouse();
        heTong();
        fare();
        host.rent();
    }
    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收房费和中介费");
    }
    //签合同
    public void heTong(){
        System.out.println("签租房合同");
    }
}
____________________________________________________________________________________________
//租房的人
public class Client {
    public static void main(String[] args) {
        //房东出租房子
        Host host = new Host();
        //代理，中介帮房东租房子，代理角色会有其他附属操作
        Proxy proxy = new Proxy(host);
        //通过中介直接租房
        proxy.rent();
    }
}
____________________________________________________________________________________________
中介带你看房
签租房合同
收房费和中介费
房东出租房子

进程已结束,退出代码0

代理模式的好处：

可以使真实角色的操作更加存粹，——不去关注繁琐的公共业务
公共业务交给代理角色，——实现了业务的分工
公共业务发生扩展的时候，方便集中管理

缺点：

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

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理

静态代理（二）

AOP实现机制

增加日志功能

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

在这里插入图片描述

代码步骤：

接口
真实角色
代理角色
客户端访问代理角色

public interface UserService {
    public void add();
    public void update();
    public void delete();
    public void select();
}
____________________________________________________________________________________________
//真实对象
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }
    @Override
    public void update() {
        System.out.println("更改了一个用户");
    }
    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void select() {
        System.out.println("查到了一个用户");
    }
}
____________________________________________________________________________________________
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 update() {
        log("update");
       userService.update();
    }
    @Override
    public void delete() {
        log("delete");
       userService.delete();
    }
    @Override
    public void select() {
        log("select");
       userService.select();
    }
    //日志方法
    public void log(String msg){
        System.out.println("[debug]:使用了"+msg+"方法");
    }
}
____________________________________________________________________________________________
public class Client {
    public static void main(String[] args) {
        UserServiceImpl service = new UserServiceImpl();
        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(service);
        proxy.add();
        proxy.delete();
        proxy.update();
        proxy.select();
    }
}
____________________________________________________________________________________________
[debug]:使用了add方法
增加了一个用户
[debug]:使用了delete方法
删除了一个用户
[debug]:使用了update方法
更改了一个用户
[debug]:使用了select方法
查到了一个用户

进程已结束,退出代码0

动态代理

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

Javassist是一个开源的分析、编辑和创建Java字节码的类库。是由东京工业大学的数学和计算机科学系的 Shigeru Chiba (千叶滋)所创建的。它已加入了开放源代码JBoss 应用服务器项目，通过使用Javassist对字节码操作为JBoss实现动态"AOP"框架。

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

InvocationHandler：——是由代理实例的，调用处理程序实现的接口，每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。

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);
}

动态代理实现

//租房的接口
public interface Rent {
    //出租房屋
    public void rent();
}
____________________________________________________________________________________________
//房东
public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东出租房子");
    }
}
____________________________________________________________________________________________
//用这个类，自动生成代理类
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 rusult = method.invoke(rent,args);
        //收中介费
        fare();
        return rusult;
    }
    public void seeHouse(){
        System.out.println("中介带看房子");
    }
    public void fare(){
        System.out.println("中介收中介费");
    }

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

        //代理角色：——现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们调用的接口对象
        pih.setRent(host);
        //这里的proxy就是动态生成的，我们并没有写！！
        Rent proxy = (Rent)pih.getProxy();

        proxy.rent();
    }
}

____________________________________________________________________________________________
中介带看房子
房东出租房子
中介收中介费

万能动态代理类：

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 {
        //动态代理的本质就是使用反射机制实现
        Object rusult = method.invoke(target,args);
        return rusult;
    }
}

写一个User Service

public interface UserService {
    public void add();
    public void update();
    public void delete();
    public void select();
}
____________________________________________________________________________________________
//真实对象
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }
    @Override
    public void update() {
        System.out.println("更改了一个用户");
    }
    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    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);
    }
    @Override
    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        //动态代理的本质就是使用反射机制实现
        Object rusult = method.invoke(target,args);
        return rusult;
    }
    //执行方法
    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

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

        pih.setTarget(service);//设置要代理的对象
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();

        proxy.add();
        proxy.delete();
    }
}
____________________________________________________________________________________________
执行了add方法
增加了一个用户
执行了delete方法
删除了一个用户

进程已结束,退出代码0
____________________________________________________________________________________________

静态代理有的它都有，静态代理没有的，它也有！

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
公共的业务由代理来完成 . 实现了业务的分工 ,
公共业务发生扩展时变得更加集中和方便 .
一个动态代理 , 一般代理某一类业务
一个动态代理可以代理多个类，代理的是接口！

AOP

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

Aop在Spring中的作用

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

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

在这里插入图片描述

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

通知类型	连接点	实现接口
前置通知	方法方法前	org.springframework.aop.MethodBeforeAdvice
后置通知	方法后	org.springframework.aop.AfterReturningAdvice
环绕通知	方法前后	org.aopalliance.intercept.MethodInterceptor
异常抛出通知	方法抛出异常	org.springframework.aop.ThrowsAdvice
引介通知	类中增加新的方法属性	org.springframework.aop.IntroductionInterceptor

即AOP在不改变原有代码的情况下，去新增功能。

使用Spring实现AOP

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

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

方式一：使用Spring的API接口实现

<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

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

    <!--注册bean-->
    <bean id="userService" class="com.fwl.service.userServiceImpl"></bean>
    <bean id="log" class="com.fwl.log.Log"></bean>
    <bean id="afterLog" class="com.fwl.log.AfterLog"></bean>

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

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

public interface UserService {
    public void add();
    public void select();
    public void delete();
    public void update();
}
____________________________________________________________________________________________
package com.fwl.service;

public class userServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了 一个用户");
    }

    @Override
    public void select() {
        System.out.println("查询了 一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了 一个用户");
    }

    @Override
    public void update() {
        System.out.println("更新了 一个用户");
    }
}
____________________________________________________________________________________________
package com.fwl.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {
    @Override
    //method: 要执行的目标对象的方法
    //object: 参数
    //target: 目标对象
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}
____________________________________________________________________________________________
public class AfterLog implements AfterReturningAdvice {
    @Override
    //returnValue: 返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}
____________________________________________________________________________________________
public class Mytest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口：注意点
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}
____________________________________________________________________________________________
com.fwl.service.userServiceImpl的add被执行了
增加了 一个用户
执行了add方法，返回结果为：null

进程已结束,退出代码0

方式二：自定义切面来实现AOP

<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

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

    <!--注册bean-->
    <bean id="userService" class="com.fwl.service.userServiceImpl"></bean>
    <bean id="log" class="com.fwl.log.Log"></bean>
    <bean id="afterLog" class="com.fwl.log.AfterLog"></bean>

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

        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut" />
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
    
    <!--方式二：自定义类 -->
    <bean id="diy" class="com.fwl.diy.DiyPointCut"/>
    <aop:config>
        <!--自定义切面，ref要引用到了类  -->
        <aop:aspect ref="diy">
            <!--切入点 -->
            <aop:pointcut id="point" expression="execution(* com.fwl.service.userServiceImpl.*())"/>
            <!--通知 -->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
</beans>

package com.fwl.diy;

public class DiyPointCut {
    public void before(){
        System.out.println("===========方法执行前===========");
    }
    public void after(){
        System.out.println("===========方法执行后===========");
    }
}
____________________________________________________________________________________________
public class Mytest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口：注意点
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}
____________________________________________________________________________________________
===========方法执行前===========
增加了 一个用户
===========方法执行后===========

进程已结束,退出代码0

方式三：使用注解实现AOP

<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--方式三：使用注解实现AOP -->
    <bean id="AnnotationPointCut" class="com.fwl.diy.AnnotationPointCut"></bean>
    <!--开启注解支持===》自动代理-->
    <aop:aspectj-autoproxy/>
</beans>

//方式三：使用注解方式实现AOP==>注解标注这个类为切面

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;

@Aspect//注解标注这个类为切面
public class AnnotationPointCut {
    @Before("execution(* com.fwl.service.userServiceImpl.*(..))")
    public void before(){
        System.out.println("=======方法执行前=======");
    }
    @After("execution(* com.fwl.service.userServiceImpl.*(..))")
    public void after(){
        System.out.println("=======方法执行后=======");
    }
    //在环绕增强中我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.fwl.service.userServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {  //连接点（JointPoint）:与切入点匹配的执行点
        System.out.println("环绕前");
        Signature signature = jp.getSignature(); //获得签名
        System.out.println("signature:"+signature);
        //执行方法
        Object proceed = jp.proceed();
        System.out.println("环绕后");
        System.out.println(proceed);
    }
}
____________________________________________________________________________________________
public interface UserService {
    public void add();
    public void select();
    public void delete();
    public void update();
}
____________________________________________________________________________________________
public class userServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了 一个用户");
    }

    @Override
    public void select() {
        System.out.println("查询了 一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了 一个用户");
    }

    @Override
    public void update() {
        System.out.println("更新了 一个用户");
    }
}
____________________________________________________________________________________________
public class Mytest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口：注意点
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}
____________________________________________________________________________________________
环绕前
signature:void com.fwl.service.UserService.add()
=======方法执行前=======
增加了 一个用户
=======方法执行后=======
环绕后
null

进程已结束,退出代码0

整合Mybatis

步骤：

导入相关jar包
- junit
- mybatis
- mysql数据库
- spring相关
- aop织入
- mybatis-spring【new】
编写配置文件
测试

回忆Mybatis

编写实体类
编写核心配置文件
编写接口
编写Mapper.xml
测试

文件目录：com.fwl.book 和 com.fwl.mapper

book包下的Book实体类

mapper包下的BookMapper 和 BookMapper.xml

配置pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>spring-07-mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
    <packaging>jar</packaging>
    <repositories>
        <repository>
            <id>repository.spring.milestone</id>
            <name>Spring Milestone Repository</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>
        <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.3.24</version>
        </dependency>
        <!--spring操作数据库的话，还需要spring-jdbc的包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>6.0.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </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>3.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

</project>

resources下的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">
<!--configuratioon核心配置文件-->
<configuration>

    <typeAliases>
        <package name="com.fwl.book"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/book?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.fwl.mapper.BookMapper"/>
    </mappers>
</configuration>

Book实体类

@Data
public class Book {
    private int id;
    private String name;
    private int status;

    public Book() {
    }

    public Book(int id, String name, int status) {
        this.id = id;
        this.name = name;
        this.status = status;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", status=" + status +
                '}';
    }
}

BookMapper

package com.fwl.mapper;

import com.fwl.book.Book;

import java.util.List;

public interface BookMapper {
    public List<Book> selectBook();
}

BookMapper.xml

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

    <select id="selectBook" resultType="book">
        select * from book.book_type;
    </select>

</mapper>

编写Test测试文件

public class MyTest {
    @Test
    public void test() throws IOException {
        String resources = "mybatis-config.xml";
        InputStream in = Resources.getResourceAsStream(resources);

        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sessionFactory.openSession(true);

        BookMapper mapper = sqlSession.getMapper(BookMapper.class);
        List<Book> bookList = mapper.selectBook();

        for (Book book : bookList) {
            System.out.println(book);
        }

    }
}
______________________________________________________________________________________________
Book{id=1, name='JavaSE', status=0}
Book{id=2, name='C#', status=1}
Book{id=3, name='JavaScript', status=1}
Book{id=4, name='Struts', status=1}
Book{id=5, name='Hibernate', status=1}
Book{id=6, name='Vue.js', status=1}
Book{id=7, name='HTML', status=1}
Book{id=8, name='MYSSM', status=0}
Book{id=20, name='www', status=1}
Book{id=21, name='1', status=1}
Book{id=22, name='22', status=1}

进程已结束,退出代码0

测试成功~拿到数据

整合方式一

编写数据源配置
sqlSessionFactory
sqlSessionTemplate
需要给接口加实现类
将自己写的实现类注入到Spring中
测试使用

<!--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.cj.jdbc.Driver"/>
       <property name="url" value="jdbc:mysql://localhost:3306/book?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="mapperLocations" value="classpath:com/fwl/mapper/BookMapper.xml"/>
    </bean>

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

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

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }
    @Override
    public List<Book> selectBook() {
        BookMapper mapper = sqlSession.getMapper(BookMapper.class);
        return mapper.selectBook();
    }
}

<bean id="bookMapper" class="com.fwl.mapper.BookMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        BookMapper bookMapper = context.getBean("bookMapper",BookMapper.class);
        for(Book book : bookMapper.selectBook()){
            System.out.println(book);
        }

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>spring-07-mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
    <packaging>jar</packaging>
    <repositories>
        <repository>
            <id>repository.spring.milestone</id>
            <name>Spring Milestone Repository</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>
    <dependencies>
        <!--MySQL驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>
        <!--MyBatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>3.0.1</version>
        </dependency>
        <!--Spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.24</version>
        </dependency>
        <!--spring操作数据库的话，还需要spring-jdbc的包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>6.0.2</version>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

</project>

Book

@Data
public class Book {
    private int id;
    private String name;
    private int status;

    public Book() {
    }

    public Book(int id, String name, int status) {
        this.id = id;
        this.name = name;
        this.status = status;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }
}
_____________________________________________________________________________________________________
public interface BookMapper {
    public List<Book> selectBook();
}
_____________________________________________________________________________________________________
public class BookMapperImpl implements BookMapper{
    //我们的所有操作，都使用sqlSession来执行，在原来，现在都使用SqlSessionTemplate;
    private SqlSessionTemplate sqlSession;

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

    @Override
    public List<Book> selectBook() {
        BookMapper mapper = sqlSession.getMapper(BookMapper.class);
        return mapper.selectBook();
    }
}
_____________________________________________________________________________________________________
BookMapper.xml
    
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fwl.mapper.BookMapper">

    <select id="selectBook" resultType="book">
        select * from book.book_type;
    </select>

</mapper>
_____________________________________________________________________________________________________

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">
<!--configuratioon核心配置文件-->
<configuration>

    <typeAliases>
        <package name="com.fwl.book"/>
    </typeAliases>

<!--    <mappers>-->
<!--        <mapper class="com.fwl.mapper.BookMapper"/>-->
<!--    </mappers>-->
</configuration>

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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.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.cj.jdbc.Driver"/>
       <property name="url" value="jdbc:mysql://localhost:3306/book?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="mapperLocations" value="classpath:com/fwl/mapper/BookMapper.xml"/>
    </bean>
    <!--SqlSessionTemplate :就是我们使用的sqlSession   -->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入SqlSessionFactory，因为它没有set方法  -->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <!-- -->
    <bean id="bookMapper" class="com.fwl.mapper.BookMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
</beans>

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

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

    <!-- -->
    <bean id="bookMapper" class="com.fwl.mapper.BookMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
</beans>

MyTest

public class MyTest {
    @Test
    public void test() throws IOException {

        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        BookMapper bookMapper = context.getBean("bookMapper",BookMapper.class);
        for(Book book : bookMapper.selectBook()){
            System.out.println(book);
        }

    }
}
_____________________________________________________________________________________________________
Book{id=1, name='JavaSE', status=0}
Book{id=2, name='C#', status=1}
Book{id=3, name='JavaScript', status=1}
Book{id=4, name='Struts', status=1}
Book{id=5, name='Hibernate', status=1}
Book{id=6, name='Vue.js', status=1}
Book{id=7, name='HTML', status=1}
Book{id=8, name='MYSSM', status=0}
Book{id=20, name='www', status=1}
Book{id=21, name='1', status=1}
Book{id=22, name='22', status=1}

进程已结束,退出代码0

查询数据成功~

整合方式二

BookMapperImpl2

public class BookMapperImpl2 extends SqlSessionDaoSupport implements BookMapper {
    @Override
    public List<Book> selectBook() {
        return getSqlSession().getMapper(BookMapper.class).selectBook();
    }
}

ApplicationContext

<bean id="bookMapper2" class="com.fwl.mapper.BookMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

MyTest

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        BookMapper bookMapper = context.getBean("bookMapper2",BookMapper.class);
        for(Book book : bookMapper.selectBook()){
            System.out.println(book);
        }
    }
}
____________________________________________________________________________________________________________
Book{id=1, name='JavaSE', status=0}
Book{id=2, name='C#', status=1}
Book{id=3, name='JavaScript', status=1}
Book{id=4, name='Struts', status=1}
Book{id=5, name='Hibernate', status=1}
Book{id=6, name='Vue.js', status=1}
Book{id=7, name='HTML', status=1}
Book{id=8, name='MYSSM', status=0}
Book{id=20, name='www', status=1}
Book{id=21, name='1', status=1}
Book{id=22, name='22', status=1}

进程已结束,退出代码0

查询数据成功~

声明式事务

事务

把一组业务当成一个业务实现，要么都成功，要么都失败
事务在项目开发中，十分重要——涉及到数据的一致性
确保完整性和一致性

事务的ACID原则

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

Spring中的事务管理

声明式事务：AOP应用事务——不影响代码
编程式事务：需要在代码中，进行事务的管理——try catch控制事务回滚

声明式事务

<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
       http://www.springframework.org/schema/tx
       https://www.springframework.org/schema/tx/spring-tx.xsd">
    
    <!--配置声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="dataSource"/>
    </bean>
    <!--结合AOP实现事务的织入-->
    <!--配置事务的通知：-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给哪些方法配置事务-->
        <!--配置事务的传播特性： new-->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="query" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!--配置事务切入-->
    <aop:config>
        <!--谁需要切入事务就配置什么文件-->
        <aop:pointcut id="txPointCut" expression="execution(* com.fwl.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
</beans>