spring-CSDN博客

本文链接：https://blog.csdn.net/qq_51637827/article/details/127420607

6、使用注解开发

在Spring4之后要使用注解开发必须得要导入aop的包导入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DuHfLI8R-1666229822693)(C:\Users\28280\AppData\Roaming\Typora\typora-user-images\image-20221005214208590.png)]

使用注解需要导入Context约束，增加注解的支持！

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

bean

属性如何注入

//等价于  <bean id="user" class="com.oy.pojo.User">
//@Component 组件
@Component
public class User {
    //相当于：<property name="name" value="欧阳"/>
    @Value("欧阳")
    public String name;
}

衍生的注解

@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层
- dao【@Repository】
- service 【@Service】
- controller【@Controller】
  
  这四个注解功能都是一样的，都是代表将某个类注册到Spring某个容器中，装配Bean

自动装配

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

作用域

@Component
@Scope("singleton") //配置单例或者原型
public class User {
    //相当于：<property name="name" value="欧阳"/>
    @Value("欧阳")
    public String name;
}

小结

xml与注解
- xml更加万能，适用于任何场合! 维护方便简单
- 注解不是自己类用不了，维护相对复杂！
xml与注解最佳实践：
- xml用来管理bean;
- 注解只负责完成属性的注入
- 我们在使用的过程中，只需要注意一个问题，必须让注解生效：就需要开启注解的支持
```

<context:annotation-config/>

<context:component-scan base-package="com.oy.pojo" />
```
2.5、完全使用Java的方式配置Spring

我们现在要完全不使用Spring的xml配置了，全权交给Java来做

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aG7MzOBJ-1666229822695)(C:\Users\28280\AppData\Roaming\Typora\typora-user-images\image-20221005231844447.png)]

实体类

package com.oy.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

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

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

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

配置文件

import com.oy.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

//这个也会被Spring容器托管，注册到容器中，因为他本来就是一个@Component
//@Configuration代表这是一个配置类，就和我们之前看的beans.xml一样
@Configuration
@ComponentScan("com.oy.pojo")
@Import(myConfig2.class) //引入另一个类中实现的bean
public class myConfig {

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

测试类

import com.oy.config.myConfig;
import com.oy.pojo.User;
import com.sun.org.apache.bcel.internal.generic.NEW;
import javafx.application.Application;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

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

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

7、代理模式

为什么要学习代理模式? 因为这就是Spring Aop的底层！【SpringAOP和SpringMVC】

代理模式的分类：

静态代理
动态代理
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wVG8NMVd-1666229822696)(C:\Users\28280\AppData\Roaming\Typora\typora-user-images\image-20221006210538884.png)]

7.1、静态代理

角色分析：

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

代码步骤：

接口

//租房子
public interface Ren {
    public void ren();
}

真实角色

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

代理角色

package com.oy.demo01;

public class person implements Ren{
    private Host host;

    public person() {
    }

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

    @Override
    public void ren() {
        host.ren();
        seeHost();
        getMoney();
    }
    //看房
    public void seeHost(){
        System.out.println("中介带看房子");
    }
    //收取中介费
    public void getMoney(){
        System.out.println("中介收取中介费");
    }
}

客户端访问代理角色

package com.oy.demo01;

public class my {
    public static void main(String[] args) {
        //房东出租房子
        Host host=new Host();
        //代理 中介代房东出租房子 但是一般中介会有一些附属操作
        person person=new person(host);
        //不用面向房东 直接找中介
        person.ren();
    }
}

代理模式的好处：

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

缺点：

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

7.2、加深理解

聊聊AOP

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fWoFOjtT-1666229822697)(C:\Users\28280\AppData\Roaming\Typora\typora-user-images\image-20221006233745072.png)]

7.3、动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口-----JDK动态代理配【我们在这里使用】
- 基于类：cglib
- java字节码实现：javasist

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

InvocationHandler

动态代理的好处：

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

8、什么是Aop

AOP：Aspect Oriented Programming，面向切面编程。
通过预编译和运行期动态代理实现程序功能的统一维护。
在Spring框架中，AOP就是一个很重要的功能。

AOP 利用一种称为横切的技术，剖开对象的封装，并将影响多个类的公共行为封装到一个可重用模块，组成一个切面，即 Aspect 。
"切面"就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，利于可操作性和可维护性。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YsB8sucl-1666229822698)(C:\Users\28280\AppData\Roaming\Typora\typora-user-images\image-20221008213032108.png)]

8.1、Aop在Spring中的作用

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

横切关注点：跨越应用程序多个模块的方法或功能，即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点，如日志，安全，缓存，事务等等
切面（ASPECT）:横切关注点被模块化的特殊对象，即，他是一个类
通知（ASPECT）：切面必须要完成的工作，即，他是类中的一个方法
目标（Target）：被通知对象
代理（Proxy）:向目标对象应用通知之后创建的对象
切入点（PointCut）:切面通知执行的地点的定义、
连接点（JoinPoint）:与切入点匹配的执行点
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V98k2gVl-1666229822698)(C:\Users\28280\AppData\Roaming\Typora\typora-user-images\image-20221008214250062.png)]

8.2、使用Spring实现Aop

[重点]使用AOP注入，需要导入一个依赖包

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.9.1</version>
</dependency>
</dependencies>

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

接口：

package com.oy.service;

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

实现类：

package com.oy.service;

public class UserServiceImp 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.oy.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog  implements AfterReturningAdvice {
    //returnValue :返回值
    public void afterReturning(Object returnValue, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("执行了"+method.getName()+"返回结果为"+returnValue);
    }
}

日志类2

package com.oy.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

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

配置文件

<?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.oy.service.UserServiceImp"/>
    <bean id="log" class="com.oy.log.log"/>
    <bean id="afterLog" class="com.oy.log.AfterLog"/>
    <!--方式一，使用原生SpringApi接口-->
    <!--配置Aop 需要导入aop的约束-->
    <aop:config>
        <!-- 切入点  expression:表达式：expression（要执行的位置！ * * * *）-->
        <aop:pointcut id="pointcut" expression="execution(* com.oy.service.UserServiceImp.*(..))"/>
        <!--    执行环绕增强！-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut" />
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试类：

import com.oy.service.UserService;
import com.oy.service.UserServiceImp;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

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

<!--    方式二-->
<bean id="diy" class="com.oy.diy.DiyPointCut"/>
<aop:config>
    <!--        自定义切面：ref要引用的类-->
    <aop:aspect ref="diy">
        <!--切入点-->
        <aop:pointcut id="point" expression="execution(* com.oy.service.UserServiceImp.*(..))"/>
        <!-- 通知 设置执行地方-->
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>
</beans>

方式三：使用注解实现：

<!--    方式三-->
<bean id="annotationPointCut" class="com.oy.diy.AnnotationPontCut"/>
<aop:aspectj-autoproxy/>

新增加类

package com.oy.diy;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect//标注这个类是一个切面
public class AnnotationPontCut {
    @Before("execution(* com.oy.service.UserServiceImp.*(..))")
    public void before(){
        System.out.println("======方法执行前======");
    }
}

9、整合Mybatis

步骤：

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

9.1、回忆mybatis

导入配置文件

<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.47</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.1.9.RELEASE</version>
    </dependency>
    <!--        spring操作数据库的话，还需要一个spring-jdb-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>

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

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.9.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>

编写实体类

package com.oy.pojo;

import lombok.Data;

@Data
public class User {
    private int id;
    private String name;
    private String pwd;
}

编写核心配置文件

<?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 核心配置文件-->
<configuration>
    <!--别名 -->
    <typeAliases>
        <package name="com.oy.pojo"/>
    </typeAliases>
    <!-- 环境模式：development开发模式 work工作模式 -->
    <environments default="development">
        <!--环境变量 -->
        <environment id="development">
             <!--事务管理器 -->
            <transactionManager type="JDBC" />
               <!--数据源 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/data?useSSL=true"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper class="com.oy.mapper.UserMapper"/>
    </mappers>

</configuration>

编写接口

package com.oy.mapper;

import com.oy.pojo.User;

import java.util.List;

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

编写mapper.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.oy.mapper.UserMapper">
    <select id="SelectUser" resultType="User">
        select *from User;
    </select>
</mapper>

编写测试

import com.oy.mapper.UserMapper;
import com.oy.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MyTest {
    @Test
    public void test() throws IOException {
        String resources="mybatis-config.xml";
        InputStream in = Resources.getResourceAsStream(resources);
        SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList=mapper.SelectUser();
        for (User user: userList) {
            System.out.println(user);
        }

    }
}

编写数据库

create database data;
use data;
create table User(
id int,
username varchar(50),
pwd varchar(55)
);
insert into User values (1,'欧阳','1234');
insert into User values (2,'张三','6666');
insert into User values (3,'李四','8888');
insert into User values (4,'王五','99999');

9.2、MyBatis-Spring[重点]

编写数据源
sqlSessionFactory
sqlSessionTemplate
需要给接口加实现类【】
将自己写的实现类，注入到Spring
测试
较Mybatis不同处

spring-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--  DataSource:使用Spring的数据源替换MyBatis的配置 c3p0  dbcp druid
    我们这里使用Spring提供的JDBC
  -->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/data?useSSL=true"/>
        <property name="username" value="root"/>
        <property name="password" value="1234"/>
    </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/oy/mapper/*.xml"/>
    </bean>
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--       只能使用构造器注入sqlSessionFactory,因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

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

</beans>

实现类

package com.oy.mapper;

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

import java.util.List;

public class UserMapperImpl implements UserMapper {

    //我们的所有操作，在原来都使用sqlSession来执行，现在都使用SqlSessionTemplate
    private SqlSessionTemplate sqlSession;

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

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

测试类

import com.oy.mapper.UserMapper;
import com.oy.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;


public class MyTest {
    @Test
    public void test() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring-dao.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.SelectUser()) {
            System.out.println(user);
        }
    }
}

9.3、SqlSessionDaoSupport

与上述改变之处

spring-dao.xml

<!--添加一个bean-->
<bean id="userMapperTo" class="com.oy.mapper.UserMapperImplTo">
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

实现类

package com.oy.mapper;

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

import java.util.List;

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

10、声明式事务

1、回顾事务

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

事务的ACID原则

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

2、Spring中的事务管理器

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

思考：

为什么需要事务？

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

代码：

需求；在故意写错删除sql语法时同时执行查询插入修改，保证报错的前提下插入不成功，需要借住事务管理器完成

User:

package com.oy.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
//有参构造
@AllArgsConstructor
//无参构造
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String pwd;
}

UserMapper：接口

package com.oy.mapper;

import com.oy.pojo.User;

import java.util.List;

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

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

UserMapperImpl：实现类

package com.oy.mapper;

import com.oy.pojo.User;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {


    public List<User> SelectUser() {
        User user= new User(5,"小王","12345");

        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);

        mapper.addUser(user);
        mapper.deleteUser(4);

        return mapper.SelectUser();
    }

    @Override
    public int addUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).addUser(user);
    }

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

}

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

    <select id="SelectUser" resultType="User">
        select *from User;
    </select>

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

    <delete id="deleteUser" parameterType="int">
        <!--故意写错delete -->
        deletes from User where id=#{id};
    </delete>
</mapper>

Application.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="Spring-dao.xml"/>

    <bean id="UserMapper" class="com.oy.mapper.UserMapperImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>

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

    <!--  DataSource:使用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 name="url" value="jdbc:mysql://localhost:3306/data?useSSL=true"/>
        <property name="username" value="root"/>
        <property name="password" value="1234"/>
    </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/oy/mapper/*.xml"/>
    </bean>
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--       只能使用构造器注入sqlSessionFactory,因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
    <!--配置声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="datasource"/>
    </bean>
    <!--结合Aop实现事务的植入 事务管理器：唯一的Spring提供的：transaction-manager="transactionManager"-->
    <!--    配置事务通知：-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--        给哪些方法配置事务-->
        <!--        配置事务的传播特效：propagation默认REQUIRED：代表支持事务-->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="select" propagation="REQUIRED"/>
            <!--   read-only="true:只读         -->
            <tx:method name="query" read-only="true"/>
            <!--            *代表所以方法-->
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--    配置事务切入-->
    <aop:config>
        <!--    id随便起名字-->
        <aop:pointcut id="txPointCut" expression="execution(* com.oy.mapper.*.*(..))"/>
        <!--  把事务：txAdvice切进去 切入到txPointCut：也就是Mapper下面的所以类的所以方法  -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
</beans>