Spring框架的详细学习

最新推荐文章于 2025-07-13 16:13:53 发布

原创最新推荐文章于 2025-07-13 16:13:53 发布 · 803 阅读

12 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

学习笔记

框架

本文深入讲解Spring框架，包括IOC容器、AOP、JDBCTemplate和事务管理等内容。介绍了Bean的创建、注入属性、作用域、生命周期，以及基于XML和注解的管理方式。此外，还探讨了Spring对JDBC的封装和MyBatis的整合，详细阐述了事务管理的声明式和编程式方法。

Spring

1.本章学习内容

1.Spring框架概要

2.IOC容器

3.AOP

4.jdbcTemplate

5.事务管理

6.Spring5新特性

7.Spring整合MyBatis

2.Spring概要

概述:它是轻量级的开源的JavaEE框架

轻量级：他的体积小，依赖的jar包比较少，并且不需要额外依赖其他的组件
开源：免费提供源代码
框架：可以简化我们构建软件的过程

目的：为了解决企业级应用的复杂性

核心：

IOC：控制反转- 把创建对象的过程交给Spring进行管理
AOP：面向切面编程 - 不修改源码进行功能增强

优点：

方便解耦，简化开发
对AOP编程的支持
方便程序的测试
方便整合其他各种的框架
方便进行事务操作
降低API开发

3.入门案例

4.IOC容器

概述：

控制反转
综上所述：控制反转就是把创建对象，和对象的调用的过程交给Spring来管理。目的是为了降低类与类之间的耦合性。

底层原理：

XML解析
工厂模式
反射

原理图解：

在这里插入图片描述

重要概念：

IOC 容器：IOC的实现，依赖于IOC容器，而IOC容器的本质就是对象工厂
IOC容器的实现：
- BeanFactory：是最底层的接口，他只提供了最简单的容器功能：加载配置文件和创建对象
  - 当加载配置文件时，不会创建被配置的对象，只有在使用时，对象才会创建。
    - 好处：节省内存
    - 坏处：因为在服务器运行的时候去创建对象，会影响执行效率
- ApplicationContext：应用上下文，它是继承了BeanFactory。它是Spring更高级的一个容器接口，他提供了更多有用的功能
  - 当配置文件的时候，会同时创建被创建配置的对象
    - 好处：效率高，将复杂的创建过程在服务器启动时完成
    - 坏处：耗费资源

3.ApplicationContext的两个实现类

ClassPathXmlApplicationContext：从项目中的resources文件中加载配置文件
FileSystemXmlApplicationContext：从文件系统读取配置文件（需要访问权限）
AnnotionConfigApplicationContext：读取注解配置

5.IOC操作 - Bean管理

概念：IOC操作 - Bean管理是指两个操作： 1.Spring创建对象 2.Spring注入属性（属性赋值）

实现方式：

1.XML方式

2.注解方式

5.1基于XML方式-创建对象

该方式与入门案列方式相同

bean标签中常用属性

id：唯一标识，通过该属性可以找到对应的Bean标签
class：类的全限定类名

注意事项：

创建对象时，默认执行无参构造方法来完成对象的创建（反射）

5.2基于XML方式-注入属性

DI：依赖注入，它是IOC的一个具体操作

分类：

使用Set方法进行注入
使用构造器方式经行注入

演示：

1.实体类

public class Book {
    private String name;
    private String author;

    public Book(String name, String author) {
        this.name = name;
        this.author = author;
    }

    public Book() {
    }

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

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

2.配置XML文件

Set方法

属性注入通过<property>

name:实体类属性名

value:属性值

<?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">
    <!-- 创建User对象-->
    <bean id="book" class="com.wdzl.pojo.Book">
        <property name="name" value="Java从入门到入土"></property>
        <property name="author" value="詹姆士"></property>
    </bean>
</beans>

构造器方法

属性注入通过<constructor-arg>

name:实体类属性名 index:通过索引

value:属性值

<?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">
    <!-- 创建User对象-->
    <bean id="book" class="com.wdzl.pojo.Book">
<!--        <constructor-arg name="name" value="Java高级数"></constructor-arg>-->
<!--        <constructor-arg name="author" value="赵子龙"></constructor-arg>-->
        <constructor-arg index="0" value="Java高级数"></constructor-arg>
        <constructor-arg index="1" value="赵子龙"></constructor-arg>
    </bean>
</beans>

P命名空间注入

xmlns:p="http://www.springframework.org/schema/p" 引入约束

<bean id="book" class="com.wdzl.pojo.Book" p:name="Java入门宝典" p:author="詹姆士·赵大帅哥"></bean>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- P命名空间注入-->
    <bean id="book" class="com.wdzl.pojo.Book" p:name="Java入门宝典" p:author="詹姆士·赵大帅哥"></bean>


</beans>

3.测试

public class BookTest {
    @Test
    public void Test(){
        //1.加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans2.xml");
        Book book = context.getBean("book", Book.class);
        System.out.println(book);
    }
}

特殊符号注入

1.null

<constructor-arg name="name" >
           <null></null>
       </constructor-arg>

2.转义字符

<constructor-arg name="author" >
 <value>"&lt;关羽&gt;"</value>
    </constructor-arg>

3.CDATA

<constructor-arg name="author" >
           <value><![CDATA[<詹姆斯·屈波>]]></value>
       </constructor-arg>

外部Bean

1.新建Moule，在pom.xml中添加依赖

2.按照三层架构成绩：Dao，Service，Web，在dao层中添加方法，在Service层中添加对Dao层的依赖（dao成员变量，对应的set方法）

3.配置对象信息

在这里插入图片描述

内部类

1.再上一个演示案例的基础上，创建两个实体类Emp和Dept，其中Emp包含Dept对象属性

2.配置对象信息

在这里插入图片描述

级联操作

1.方式一

在这里插入图片描述

2.方式二

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3vApStu1-1617199855683)(D:\图片\20210320162814.png)]

注意事项：

针对方式2:一定要提供get. set方法，否则配置文件中的某些属性就会报红。

(基本数据类型)数组，集合属性的注入

1.创建一个实体类

在这里插入图片描述

2.配置对象属性

<?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="demo" class="com.wdzl.pojo.Demo">
       <!-- 字符串数组-->
       <property name="strings">
           <array>
               <value>你好</value>
               <value>小老弟</value>
           </array>
       </property>
       <!-- list集合-->
       <property name="list">
           <list>
               <value>hello</value>
               <value>people</value>
           </list>
       </property>
       <!-- map集合-->
       <property name="map">
           <map>
               <entry key="你好" value="世界"></entry>
               <entry key="哈哈" value="屈波"></entry>
               <entry key="好" value="唐康"></entry>
           </map>
       </property>
   </bean>

</beans>

引用数据类型

城市类：

在这里插入图片描述

省类：

在这里插入图片描述

2.配置对象信息

<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util
                           https://www.springframework.org/schema/util/spring-util.xsd">
    <util:list id="cityList">
        <value>西安</value>
        <value>宝鸡</value>
        <value>延安</value>
    </util:list>
    <bean id="province" class="com.wdzl.pojo.Province">
        <property name="cities" ref="cityList"></property>
    </bean>


<!--    <bean id="city" class="com.wdzl.pojo.City">-->
<!--        <property name="cityName" value="西安"></property>-->
<!--    </bean>-->

<!--    <bean id="city2" class="com.wdzl.pojo.City">-->
<!--        <property name="cityName" value="宝鸡"></property>-->
<!--    </bean>-->
<!--    <bean id="city3" class="com.wdzl.pojo.City">-->
<!--        <property name="cityName" value="安康"></property>-->
<!--    </bean>-->
<!--    <bean id="city4" class="com.wdzl.pojo.City">-->
<!--        <property name="cityName" value="延安"></property>-->
<!--    </bean>-->

<!--   <bean id="province" class="com.wdzl.pojo.Province">-->
<!--       <property name="cities">-->
<!--           <list>-->
<!--               <ref bean="city"></ref>-->
<!--               <ref bean="city2"></ref>-->
<!--               <ref bean="city3"></ref>-->
<!--               <ref bean="city4"></ref>-->
<!--           </list>-->
<!--       </property>-->
<!--   </bean>-->

</beans>

FactoryBean:

概述：Spring中有两种类型的Bean，一种是普通Bean，一种是工厂Bean

普通Bean:在配置文件中定义的Bean类型就是返回类型。
工厂Bean:在配置文件中配置bean类型与返回类型不同。

演示：

创建一个工厂类

/**
 * 工厂Bean类型
 */
public class MyBean implements FactoryBean<String> {
    /**
     * 获取对象:此方法中定义了注入MyBean时，真正返回的对象
     * @return
     * @throws Exception
     */
    @Override
    public String getObject() throws Exception {
        return "我是钢铁侠";
    }

    /**
     * 返回对象类型
     * @return
     */
    @Override
    public Class<?> getObjectType() {
        return null;
    }

    /**
     * 是否是单例
     * @return
     */
    @Override
    public boolean isSingleton() {
        return false;
    }


}

配置对象信息

<?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="myBean" class="com.wdzl.pojo.MyBean"></bean>
</beans>

测试案例

在这里插入图片描述

5.3 Bean的作用域

**概述：**在Spring中，设置创建Bean实例是单例还是多例。默认情况，Bean是单例。

注意：

Singleton 和 prototype 的区别：

Singleton :在加载配置文件时，对象便会创建，并且，只创建一个对象
prototype ：在加载配置文件时，并不会创建对象，在调用getBean方法时，才会创建对象，并且每次调用都会创建。

5.4 Bean的生命周期

概述：

一个对象从创建到销毁的过程

过程：

通过构造器创建Bean实例
为Bean的属性设置值或引用其他Bean（调用set）
调用Bean初始化方法
Bean对象获取
容器关闭，调用销毁Bean的方法

演示：

实体类

public class User {
    private String name;

    public User(){
        System.out.println("第一步：通过构造器创建对象");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("第二步，为Bean属性设置值");
        this.name = name;
    }
    public void init(){
        System.out.println("第三步：调用Bean初始化方法");
    }

    public void destroy(){
        System.out.println("第五步：调用Bean销毁方法");
    }


}

配置文件

<?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="user" class="com.wdzl.pojo.User" init-method="init" destroy-method="destroy">
        <property name="name" value="周星驰"></property>
    </bean>
<!--    <bean id="myBeanLast" class="com.wdzl.pojo.MyBeanLast"></bean>-->

</beans>

结果

在这里插入图片描述

在Bean的生命周期中，如果配置了后置处理，生命周期会额外增加两步

通过构造器创建Bean实例
为Bean的属性设置值或引用其他Bean（调用set）
执行后置处理
调用Bean初始化方法
执行后置处理
Bean对象获取
容器关闭，调用销毁Bean的方法

演示：

在上述演示中再加入一个实体类

/**
 * 后置处理类
 */
public class MyBeanLast implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第三步：执行后置处理+postProcessBeforeInitialization");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第五步：执行后置处理+postProcessAfterInitialization");
        return bean;
    }
}

配置文件

<?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="user" class="com.wdzl.pojo.User" init-method="init" destroy-method="destroy">
        <property name="name" value="周星驰"></property>
    </bean>
    <bean id="myBeanLast" class="com.wdzl.pojo.MyBeanLast"></bean>

</beans>

结果

在这里插入图片描述

5.5 XML方式-自动装配

概述：

根据指定的装配规则（属性名称，属性类型），Spring自动将匹配的属性经行注入

实现：

借助<bean> 标签里的autowrie属性来实现自定装配，该属性有两个值

byName：根据属性名称注入
byType：根据属性类型注入

注意：

byType：如果有多个class属性相同的bean标签，自动装配会报错

5.6 引入外部标签

<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:property-placeholder location="jdbc.properties"></context:property-placeholder>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${druid.driverClassName}"></property>
        <property name="url" value="${druid.url}"></property>
        <property name="username" value="${druid.username}"></property>
        <property name="password" value="${druid.password}"></property>
    </bean>


    <!-- 直接方式：配置连接信息-->
<!--    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">-->
<!--        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>-->
<!--        <property name="url" value="jdbc:mysql:///test"></property>-->
<!--        <property name="username" value="root"></property>-->
<!--        <property name="password" value="13992794421"></property>-->
<!--    </bean>-->

5.7基于注解方式-创建对象

注解概述：注解是代码的特殊标记

注解格式：@注解名称（属性名=属性值，属性名2=属性值2。。。。）

注解应用：它可以简化XML的配置，注解可以用在类上，属性上，方法上。

Spring针对创建对象提供了4个注解

@Component：普通类使用
@Service：Service层使用
@Controller：Web层使用
@Repository：Dao层使用

这四个注解功能是相同的，都可以用来创建Bean实例。

1.新建Model，添加依赖

2.创建Dao层实体类，在该类上添加注解

@Repository(value = "userDao")//相当于配置文件中Bean id属性
public class UserDao {
    public void addUser(){
        System.out.println("UserDao:addUser....");
    }
}

3.在配置文件中开启注解扫描

在这里插入图片描述

测试

在这里插入图片描述

5.8基于注解方式-属性注入

常用注解：

1.@AutoWired：根据属性类型进行自动重装载

2.@Qualifier :根据属性名进行注入

3.@Resource:根据类型注入，也可以根据名称注入

4.@Value:基本数据类型的注入

演示：

@AutoWired

@Qualifier

要与@AutoWired同时使用
同时使用的目的是为了解决根据属性类型无法自动

@Resource

@Value

6.AOP

概述：

面向切面编程-在不改变源码的情况下，对现有程序功能进行维护。

6.1AOP底层原理

概述：底层实用了动态代理技术

分类：两种情况的动态代理

有接口的情况：使用了JDK的动态代理
- 代理对象与被代理对象实现相同的接口
没有接口的情况，使用了CGLIB动态代理
- 通过创建子类对象，在子类中重写方法，并通过super.方法名（）调用被代理类中的方法

6.2AOP相关术语

连接点（JoinPoint）：类里面那些方法可以被增强，这些方法就叫做连接点
切入点（PoinCut）：类中实际被增强的方法，称为切入点
通知/增强（Advice）：被增强的方法中增强部分的代码称为通知或者增强
- 前置增强：在调用被增强方法前执行
- 后置增强：在调用被增强方法后执行
- 环绕增强：在调用被增强方法前后都执行
- 异常增强：在调用被增强方法出现异常时增强
- 最终增强：在调用被增强方法后，无论是否出现异常，都会被执行
切面（Aspect）：切面本身是一个动作，将增强应用到切入点的过程
代理（Proxy）
目标对象（Target）
织入（Weaving）

6.3AspectJ

概述：

AspectJ时一个独立的AOP框架，一般开发中将AspectJ 与Spring框架-起使用，进行AOP操作

实现AOP的两种方式：

1.基于XML方式实现

2.基于注解方式实现

相关依赖：

<dependencies>
<!--    Spring依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.2.7.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.7.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.7.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>5.2.7.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.2.7.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.2.7.RELEASE</version>
    </dependency>
<!-- 日志依赖-->
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.1.1</version>
    </dependency>
<!-- 测试依赖-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

<!-- aspectJ依赖-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
    </dependency>

    <dependency>
        <groupId>aopalliance</groupId>
        <artifactId>aopalliance</artifactId>
        <version>1.0</version>
    </dependency>

    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>3.3.0</version>
    </dependency>
</dependencies>

切入点表达式

概述：让Spring框架知道哪个类里面的那个方法需要增强

语法结构：

execution([权限修饰符] [返回值类型] [全限定类名] .[方法名]（[参数列表]）)
- 权限修饰符可以省略
- 返回值*代表任意返回值类型
举例
- 对com.wdzl.dao.UserDao类中的addUser方法进行增强
execution(* com.wdzl.dao.UserDao.addUser(…))

6.4AOP的实现方式一

使用原生Spring API接口

1.Service层的接口与实现类

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

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

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

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

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

2.创建日志增强类

public class log implements MethodBeforeAdvice {



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

public class AfterLog implements AfterReturningAdvice {

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

3.创建配置文件

<?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-->
    <bean id="userService" class="com.wdzl.service.impl.UserServiceImpl"></bean>
    <bean id="log" class="com.wdzl.log.log"></bean>
    <bean id="afterLog" class="com.wdzl.log.AfterLog"></bean>


<!--    方式一：使用原生Spring API接口-->
<!--    配置aop：需要导入aop的约束-->
<!--    配置aop:需要导入aop的约束-->
    <aop:config>
     <!--切入点:expression; 表达式：([权限修饰符] [返回值类型] [全限定类名] .[方法名]（[参数列表]）)-->
        <aop:pointcut id="pointcut" expression="execution(* com.wdzl.service.impl.UserServiceImpl.*(..))"/>

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

    </aop:config>

</beans>

4.测试

6.5AOP的实现方式二

方式二：自定义类

1.Service层的接口与实现类

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

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

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

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

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

2.自定义类

public class DiyPointCut {

    public void Before(){
        System.out.println("==========执行前=====");
    }


    public void After(){
        System.out.println("==========执行后=====");
    }
}

3.配置配置文件

<?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-->
    <bean id="userService" class="com.wdzl.service.impl.UserServiceImpl"></bean>
    <!--   方式二：自定义类-->
    <bean id="diy" class="com.wdzl.diy.DiyPointCut"></bean>
    <aop:config>
<!--        自定义切面， ref 要引用的类-->
        <aop:aspect ref="diy">
            <!-- 切入点-->
            <aop:pointcut id="point" expression="execution(* com.wdzl.service.impl.UserServiceImpl.*(..))"/>

            <!-- 通知-->
            <aop:before method="Before" pointcut-ref="point"></aop:before>
            <aop:after method="After" pointcut-ref="point"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

4.测试

在这里插入图片描述

6.6注解方式实现AOP

1.创建dao层接口及实现类

public interface UserDao {
    void addUser();
}

@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public void addUser() {
        
        System.out.println("天不生我李志刚");
    }
}

2.创建增强类

@Component
@Aspect//将该类生产代理对象,这个类是一个切面
public class UserDaoProxy {
    /**
     * 前置增强
     */

    @Before(value = "execution(* com.wdzl.dao.Impl.UserDaoImpl.addUser(..))")
    public void before(){
        System.out.println("before:前置增强.....");
    }



    /**
     * 最终增强
     */
    @After(value = "execution(* com.wdzl.dao.Impl.UserDaoImpl.addUser(..))")
    public void after(){
        System.out.println("after:最终增强...");
    }

    /**
     * 后置增强
     */
    @AfterReturning(value ="execution(* com.wdzl.dao.Impl.UserDaoImpl.addUser(..))")
    public void afterReturning(){
        System.out.println("AfterReturning:后置增强...");
    }

    /**
     * 异常增强
     */
    @AfterThrowing(value ="execution(* com.wdzl.dao.Impl.UserDaoImpl.addUser(..))")
    public void afterThrowing(){
        System.out.println("AfterThrowing:异常增强...");
    }

    /**
     * 环绕增强
     * 我们可以给定一个参数，代表我们要获取处理切入的点
     */
    @Around(value = "execution(* com.wdzl.dao.Impl.UserDaoImpl.addUser(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕之前...");
        joinPoint.proceed();//执行方法
        System.out.println("环绕之后...");
    }
}

3.创建配置文件

<?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
                           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:component-scan base-package="com.wdzl"></context:component-scan>


    <!--生成Aspect生成代理对象  JDK(默认  proxy-target-class="false")  cglib（proxy-target-class="true"）-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>



</beans>

4.测试

在这里插入图片描述

7.JDBCTemplate

概述：

Spring对JDBC的封装，使用它可以方便的去操作数据库

依赖：

查询：

1.一个值

2.一个对象

3.一个集合

1.实体类

在这里插入图片描述

2.dao层及其实现类

/**
 * 学生持久层
 */
public interface StudentDao {

    /**
     * 添加学生
     */
    public void addStudent(Student student);


    /**
     * 修改
     */
    void  updateStudent(Student student);


    /**
     * 删除
     */
    void delStudent(int i);


    /**
     * 查询学生列表
     * @return
     */
    List<Student> findAll();


    /**
     * 查询学生总人数
     */
    int findStudentTotal();

    Student findStudentById(int id);
}

/**
 * 学生持久层接口实现类
 */
@Repository
public class StudentDaoImpl implements StudentDao {
    //注入JDBCTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public void addStudent(Student student) {
        String sql = "insert into student (id,username,gender,birthday,address) values (?,?,?,?,?)";
        int update = jdbcTemplate.update(sql, student.getId(), student.getUsername(), student.getGender(), student.getBirthday(), student.getAddress());
        System.out.println(update);
    }

    @Override
    public void updateStudent(Student student) {
        String sql = "update student set username = ? where id = ?";
        int update = jdbcTemplate.update(sql, student.getUsername(), student.getId());
        System.out.println(update);
    }

    @Override
    public void delStudent(int i) {
        String sql = "delete from student where id = ?";
        Student student = new Student();
        student.setId(i);

        int update = jdbcTemplate.update(sql, i);
        System.out.println(update);

    }

    @Override
    public List<Student> findAll() {
        String sql = "select * from student";
        List<Student> lists = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Student.class));
        return lists;
    }

    @Override
    public int findStudentTotal() {
        String sql = "select count(id) from student";
        Integer total = jdbcTemplate.queryForObject(sql, Integer.class);
        return total;
    }


    /**
     * queryForObject()三个参数：
     * sql:sql语句
     * RowMapper接口：完成属性和字段映射的功能，常用实现类：BeanPropertyRowMapper
     * 第三个：可变参数
     * @param id
     * @return
     */
    @Override
    public Student findStudentById(int id) {
        String sql = "select * from student where id = ?";
        Student student = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Student.class),id);
        return student;
    }
}

3.service层及其实现类

/**
 * 学生业务层接口
 */
public interface StudentService {
    public void addStudent(Student student);

    void updateStudent(Student student);

    void delStudent(int i);

    int findStudentTotal();

    Student findStudentById(int id);

    List<Student> findAll();

}

@Service
public class StudentServiceImpl implements StudentService {
    //注入StudentDao
    @Autowired
    private StudentDao studentDao;


    @Override
    public void addStudent(Student student) {
        studentDao.addStudent(student);
    }

    @Override
    public void updateStudent(Student student) {
        studentDao.updateStudent(student);
    }

    @Override
    public void delStudent(int i) {

        studentDao.delStudent(i);
    }

    @Override
    public int findStudentTotal() {
        return studentDao.findStudentTotal();
    }

    @Override
    public Student findStudentById(int id) {
        return studentDao.findStudentById(id);
    }

    @Override
    public List<Student> findAll() {
        return studentDao.findAll();
    }
}

4.编写配置类

<?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
                           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:component-scan base-package="com.wdzl"></context:component-scan>
<!--数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///mybatis?useUnicode=true&amp;characterEncoding=utf-8"></property>
        <property name="username" value="root"></property>
        <property name="password" value="13992794421"></property>

    </bean>

<!--jdbcTempLate    -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>



</beans>

4.测试

public class MyTest {
    @Test
    public void test(){
        //1.读取配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        //2.创建服务层接口对象
        StudentService studentServiceImpl = context.getBean("studentServiceImpl", StudentService.class);
        Student student = new Student(0,"常山赵子龙","2000-02-08","男","长沙");

        studentServiceImpl.addStudent(student);


    }

    @Test
    public void test2(){
        //1.读取配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        //2.创建服务层接口对象
        StudentService studentServiceImpl = context.getBean("studentServiceImpl", StudentService.class);
        Student student = new Student(4,"王必武","2000-02-08","男","长沙");

        studentServiceImpl.updateStudent(student);


    }

    @Test
    public void Test(){
        //1.读取配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        //2.创建服务层接口对象
        StudentService studentServiceImpl = context.getBean("studentServiceImpl", StudentService.class);


        studentServiceImpl.delStudent(2);


    }

    @Test
    public void Test2(){
        //1.读取配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        //2.创建服务层接口对象
        StudentService studentServiceImpl = context.getBean("studentServiceImpl", StudentService.class);


        int total = studentServiceImpl.findStudentTotal();
        System.out.println(total);


    }

    @Test
    public void Test3(){
        //1.读取配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        //2.创建服务层接口对象
        StudentService studentServiceImpl = context.getBean("studentServiceImpl", StudentService.class);


        Student studentById = studentServiceImpl.findStudentById(3);
        System.out.println(studentById);


    }

    @Test
    public void findAllTest4(){
        //1.读取配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        //2.创建服务层接口对象
        StudentService studentServiceImpl = context.getBean("studentServiceImpl", StudentService.class);


        List<Student> list = studentServiceImpl.findAll();
        for (Student student : list){
            System.out.println(student);
        }

    }
}

批量添加：

    /**
     * 批量增加
     */
    void batchAdd(List<Object[]> students);

    @Override
    public void batchAdd(List<Object[]> students) {
        String sql = "insert into student (username,birthday,gender,address) values (?,?,?,?)";
        /**
         * 批量添加
         * 参数一：sql语句
         * 参数二：
         */
        int[] ints = jdbcTemplate.batchUpdate(sql, students);
        System.out.println(Arrays.toString(ints));

    }

    void batchAdd(List<Object[]> students);

  @Override
    public void batchAdd(List<Object[]> students) {
        studentDao.batchAdd(students);
    }

    public void Test5(){
        //1.读取配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        //2.创建服务层接口对象
        StudentService studentServiceImpl = context.getBean("studentServiceImpl", StudentService.class);


        List<Object[]> args = new ArrayList<>();
        Object[] o1 = {"唐康","2020-2-2","男","安康"};
        Object[] o2 = {"赵玉斌","2020-2-2","男","安康"};
        Object[] o3 = {"马超","2020-2-2","男","安康"};
        Object[] o4 = {"关羽","2020-2-2","男","安康"};

        args.add(o1);
        args.add(o2);
        args.add(o3);
        args.add(o4);

        studentServiceImpl.batchAdd(args);
    }

批量修改：

    /**
     * 批量修改
     */
    void batchUpdate(List<Object[]> lists);
        
            @Override
    public void batchUpdate(List<Object[]> lists) {
                String sql = "update student set username = ? where address = ?";
                int[] ints = jdbcTemplate.batchUpdate(sql, lists);
        System.out.println(Arrays.toString(ints));
    }


   void batchUpdate(List<Object[]> lists);

    @Override
    public void batchUpdate(List<Object[]> lists) {
        studentDao.batchUpdate(lists);
    }

  @Test
    public void Test6(){
        //1.读取配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        //2.创建服务层接口对象
        StudentService studentServiceImpl = context.getBean("studentServiceImpl", StudentService.class);


        List<Object[]> args = new ArrayList<>();
        Object[] o1 = {"你好","安康"};
        Object[] o2 = {"世界","安康"};
        Object[] o3 = {"中国","安康"};
        Object[] o4 = {"万岁","安康"};

        args.add(o1);
        args.add(o2);
        args.add(o3);
        args.add(o4);

        studentServiceImpl.batchUpdate(args);
    }

8.整合MyBatis

8.1 方式一

步骤：

1.导入相关jar包

junit
mybatis
mysql数据库
spring相关的
aop织入
mybatis-spring【new】

<?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>com.wdzl</groupId>
    <artifactId>04_spring_mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>

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

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

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

<!--        Spring操作数据库的话，还需要一个spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>

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

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


    </dependencies>


</project>

2.dao层及实现类

public interface UserDao {

    List<Account> findAll();
}

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

    public SqlSessionTemplate getSqlSession() {
        return sqlSession;
    }

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

    @Override
    public List<Account> findAll() {
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        return userDao.findAll();
    }
}

3.编写配置文件

1.编写数据源配置

2.sqlSessionFactory

3. sqlSessionTemplate

4.将自己写的实现类，注入到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
">

<!--    DataSources:使用Spring的数据源替换MyBatis的配置 c3p0 dbcp druid
  我们使用Spring提供的JDBC
-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///test"></property>
        <property name="username" value="root"></property>
        <property name="password" value="13992794421"></property>
    </bean>


<!--    SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
<!--        绑定MyBatis配置文件 -->
        <property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
        <property name="mapperLocations" value="classpath:com/wdzl/dao/UserDao.xml"></property>
    </bean>

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

    <bean id="userDaoImpl" class="com.wdzl.dao.impl.UserDaoImpl">
        <property name="sqlSession" ref="sqlSession"></property>
    </bean>


</beans>

SqlMapConfig.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>
    <!-- 设置-->
<!--    <settings>-->
<!--        <setting name="" value=""/>-->
<!--    </settings>-->

    <!-- 别名-->
<!--    <typeAliases>-->
<!--        <package name="com.wdzl"/>-->
<!--    </typeAliases>-->

</configuration

UserDao.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.wdzl.dao.UserDao"><!-- 对应dao层的全限定类名-->
    <select id="findAll" resultType="com.wdzl.pojo.Account">
        select*from account;
    </select>
</mapper>

4.测试

在这里插入图片描述

8.2方式二

1.dao层及其实现类

public class UserDaoImpl2 extends SqlSessionDaoSupport implements UserDao {


    @Override
    public List<Account> findAll() {
        return getSqlSession().getMapper(UserDao.class).findAll();
    }
}

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

<!--    DataSources:使用Spring的数据源替换MyBatis的配置 c3p0 dbcp druid
  我们使用Spring提供的JDBC
-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///test"></property>
        <property name="username" value="root"></property>
        <property name="password" value="13992794421"></property>
    </bean>


<!--    SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
<!--        绑定MyBatis配置文件 -->
        <property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
        <property name="mapperLocations" value="classpath:com/wdzl/dao/UserDao.xml"></property>
    </bean>

   <bean id="userDaoImpl" class="com.wdzl.dao.impl.UserDaoImpl">
        <property name="sqlSession" ref="sqlSession"></property>
    </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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd
">


    <import resource="classpath:Beans.xml"></import>

   <bean id="userDaoImpl2" class="com.wdzl.dao.impl.UserDaoImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
    </bean>


</beans>

3.测试

在这里插入图片描述

8.事务

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

事务ACID原则：

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

8.1Spring中的事务管理

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

8.2 事务的环境搭建

1.新建一个Module，添加相关依赖

2.编写配置文件

配置数据源
配置jdbcTemplate
开启组件扫描

3.编写dao层接口，Service层接口，及相应的实现类

4.测试

8.3事务操作

1.事务应该添加到三层架构中的service层

因为Service负责组装业务

2.在Spring中进行事务管理

编程是事务
声明式事务

3.声明式事务管理

基于注解方式
基于XML方式

4.在Spring中进行声明式事务管理，实用了AOP原理

5.Spring针对不同的框架使用了不同的API

Jdbc，MyBatis： DataSourceTransactionManager
Hibernate: HibernateTransactionManager

8.3基于XML方式的事务管理

1.编写dao层接口，Service层接口，及相应的实现类

dao层接口

public interface UserDao {

    List<Account> findAll();

    ///添加一个用户
    int addUser(Account account);

    //删除一个用户
    int deleteUser(int id);
}

实现类

public class UserDaoImpl2 extends SqlSessionDaoSupport implements UserDao {


    @Override
    public List<Account> findAll() {
        SqlSession sqlSession = getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        return userDao.findAll();
    }

    @Override
    public int addUser(Account account) {
        return getSqlSession().getMapper(UserDao.class).addUser(account);
    }

    @Override
    public int deleteUser(int id) {
        return getSqlSession().getMapper(UserDao.class).deleteUser(id);
    }
}

service层接口

public interface UserService {

    List<Account> findAll();

    ///添加一个用户
    int addUser(Account account);

    //删除一个用户
    int deleteUser(int id);
}

实现类

public class UserServiceImpl extends SqlSessionDaoSupport implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao){

        this.userDao = userDao;
    }

    @Override
    public List<Account> findAll() {
        Account account = new Account(0, "yy", 666);
        userDao.addUser(account);
        userDao.deleteUser(9);
        return userDao.findAll();
    }

    @Override
    public int addUser(Account account) {
       return userDao.addUser(account);
    }

    @Override
    public int deleteUser(int id) {
        return userDao.deleteUser(id);
    }
}

编写配置文件

UserDao.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.wdzl.dao.UserDao"><!-- 对应dao层的全限定类名-->
    <select id="findAll" resultType="com.wdzl.pojo.Account">
        select*from account;
    </select>

    <insert id="addUser" parameterType="com.wdzl.pojo.Account">
        insert into account (id,name,money) values (#{id},#{name},#{money})
    </insert>

    <delete id="deleteUser" parameterType="int">
        delete from account where id = #{id}
    </delete>
</mapper>

Beans.xml

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

<!--    DataSources:使用Spring的数据源替换MyBatis的配置 c3p0 dbcp druid
  我们使用Spring提供的JDBC
-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///test"></property>
        <property name="username" value="root"></property>
        <property name="password" value="13992794421"></property>
    </bean>


<!--    SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
<!--        绑定MyBatis配置文件 -->
        <property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
        <property name="mapperLocations" value="classpath:com/wdzl/dao/UserDao.xml"></property>
    </bean>

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


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

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

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

</beans>

SqlMapConfig.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>
    <!-- 设置-->
<!--    <settings>-->
<!--        <setting name="" value=""/>-->
<!--    </settings>-->

    <!-- 别名-->
<!--    <typeAliases>-->
<!--        <package name="com.wdzl"/>-->
<!--    </typeAliases>-->

</configuration>

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


    <import resource="classpath:Beans.xml"></import>

    <bean id="userDaoImpl" class="com.wdzl.dao.impl.UserDaoImpl">
        <property name="sqlSession" ref="sqlSession"></property>
    </bean>

    <bean id="userDaoImpl2" class="com.wdzl.dao.impl.UserDaoImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
    </bean>

    <bean id="userServiceImpl" class="com.wdzl.service.impl.UserServiceImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
        <property name="userDao" ref="userDaoImpl2"></property>
    </bean>



</beans>

测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8aipIwyj-1617199855710)(D:\图片\Aop.png)]

8.4基于注解方式的事务管理

- propagation ：事务传播行为
- isolation: 事务隔离级别
- timeout:超时时间
- readOnly:是否只读
- rollbackFor:回滚
- noRollbackFor：不回滚

1.创建实体类

/**
 * 账户类
 */
public class Account {
    private int id;
    private String name;
    private double money;

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

    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 double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

2.数据库连接配置类

/**
 * 数据库连接配置类
 */

public class JdbcConfig {
    @Bean//将DataSource注入Spring容器中
    public DataSource getDataSource(){
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///test?useUnicode=true&characterEncoding=utf-8");
        dataSource.setUsername("root");
        dataSource.setPassword("13992794421");
        return dataSource;
    }

    @Bean//将SqlSessionFactory注入到Spring容器中
    public SqlSessionFactoryBean create(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
        sqlSessionFactory.setDataSource(dataSource);
        Resource resource = new ClassPathResource("SqlMapConfig.xml");
        sqlSessionFactory.setConfigLocation(resource);
        return sqlSessionFactory;
    }
}

3.配置类

@Configuration//配置类
@ComponentScan(basePackages = "com.wdzl")//组件扫描
@Import(value = {JdbcConfig.class,TransactionConfig.class})//引入其他配置类
@EnableTransactionManagement//开启事务
public class SpringConfig {
}

4.事务管理类

/**
 * 事务管理类
 */
public class TransactionConfig {
    //将我们的事务管理对象注入容器
    @Bean
    public PlatformTransactionManager createTransactionManager(DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }
}

5.dao层及其实现类

public interface AccountDao {
    /**
     * 根据用户名查询账户信息
     * @param name
     * @return
     */
    @Select("select*from account where name = #{name}")
    Account findAccountByName(String name);

    /**
     * 更新账户信息
     * @param account
     */
    @Update("update account set name = #{name},money=#{money} where id = #{id}")
    void updateAccount(Account account);
}

@Repository
public class AccountDaoImpl implements AccountDao {
    //注入sqlSession工厂
    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    @Override
    public Account findAccountByName(String name) {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        AccountDao accountDao = sqlSession.getMapper(AccountDao.class);

        return accountDao.findAccountByName(name);
    }

    @Override
    public void updateAccount(Account account) {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
        accountDao.updateAccount(account);


    }
}

6.service层及其实现类

/**
 * 账户业务逻辑层接口
 */
public interface AccountService {

    /**
     * 转账业务
     * @param sourceName 转出账户姓名
     * @param targetName 转入账户姓名
     * @param money 转动金钱
     */
    void transfer(String sourceName,String targetName,double money);
}

@Service
@Transactional//开启事务
public class AccountServiceImpl implements AccountService {
    //注入数据访问层
    @Autowired
    private AccountDao accountDao;


    @Override
    public void transfer(String sourceName, String targetName, double money) {
        //查询转出账户对象
        Account source = accountDao.findAccountByName(sourceName);
        //查询注入账户是否存在
        Account target = accountDao.findAccountByName(targetName);
        //判断账户是否存在
        if (source != null && target != null ){
            //设置转入转出金额
            source.setMoney(source.getMoney() - money);
            target.setMoney(target.getMoney() + money);
            //更新账户信息
            accountDao.updateAccount(source);
//            System.out.println(3/0);
            accountDao.updateAccount(target);

        }
    }
}

7.账户控制层

/**
 * 账户控制层
 */
@Controller
public class AccountController {

    @Autowired
    private AccountService accountService;

    public void transfer(String sourceName,String targetName,double money){
        try {
            accountService.transfer(sourceName,targetName,money);
            System.out.println("转账成功");
        } catch (Exception e) {
            System.out.println("转账失败");
        }
    }
}

8.编写配置类

<?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>
    <mappers>
        <mapper class="com.wdzl.dao.AccountDao"></mapper>
    </mappers>
</configuration>

9.测试

public class MyTest {
    @Test
    public void Test(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        AccountController accountController = context.getBean("accountController", AccountController.class);
        accountController.transfer("李明","张三",500);
    }
}

标签

#java