Spring5 初学笔记

傷城~ 2023-10-03 17:40 26阅读 0赞

### 介绍 ###

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。  
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

**导入相关maven**

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

**优点**  
Spring是一个开源的免费框架（容器）！  
Spring是一个轻量级的非入侵式的框架  
控制反转（IOC），面向切面编程（AOP）！  
支持事务的处理，对框架整合的支持  
开源免费容器，轻量级非侵入式，控制反转，面向切面，支持事务，支持框架整合

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

### IOC ###

**介绍**  
控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

Class A中用到了Class B的对象b，一般情况下，需要在A的代码中显式的new一个B的对象。  
采用依赖注入技术之后，A的代码只需要定义一个私有的B对象，不需要直接new来获得这个对象，而是通过相关的容器控制程序来将B对象在外部new出来并注入到A类里的引用中。而具体获取的方法、对象被获取时的状态由配置文件（如XML）来指定。

//在Service层的实现类(UserServiceImpl)增加一个Set()方法
    //利用set动态实现值的注入！
    private UserDao userDao;
    public void setUserDao(UserDao userDao){
        
        this.userDao = userDao;
    }

((UserServiceImpl)userService).setUserDao(new UserDaoImpl());

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

本质上解决了问题，程序员不用再去管理对象的创建  
系统的耦合性大大降低，可以更专注在业务的实现上  
这是IOC（控制反转）的原型，反转(理解)：主动权交给了用户

### HolleSpring ###

1.导包

2.创建pojo实体类

package pojo;
    
    public class Hello {
        
    
    	private String str;
    	
    	public String getStr() {
        
    		return str;
    	}
    
    	public void setStr(String str) {
        
    		this.str = str;
    	}
    	
    	@Override
    	public String toString() {
        
    		return "Holle [str=" + str + "]";
    	}
    }

3.xml配置

4.测试

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

### IOC创建对象的方式 ###

**使用无参构造创建对象，默认。 或者使用有参构造（如下）**

下标赋值  
index指的是有参构造中参数的下标，下标从0开始;

类型赋值

直接通过参数名（掌握）

ps:  
就算是new 两个对象，也是只有一个实例（单例模式：全局唯一）

User user = (User) context.getBean("user");
    User user2 = (User) context.getBean("user");
    system.out.println(user == user2)//结果为true

### Spring 配置 ###

别名

bean配置

<bean id="user" class="pojo.User" name="u1 u2,u3;u4">
        <property name="name" value="chen"/>
    </bean>

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

### 依赖注入（DI） ###

依赖注入：set注入！

依赖：bean对象的创建依赖于容器  
注入：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
            https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    	<bean id="address" class="pojo.Address">
    		<property name="address" value="address你好" />
    	</bean>
    
    	<bean id="student" class="pojo.Student">
    		
    		<property name="name" value="name你好" />
    		
    		<property name="address" ref="address" />
    
    		
    		<property name="books">
    			<array>
    				<value>三国</value>
    				<value>西游</value>
    				<value>水浒</value>
    			</array>
    		</property>
    
    		
    		<property name="hobbies">
    			<list>
    				<value>唱</value>
    				<value>跳</value>
    				<value>rap</value>
    				<value>篮球</value>
    			</list>
    		</property>
    
    		
    		<property name="card">
    			<map>
    				<entry key="username" value="root" />
    				<entry key="password" value="root" />
    			</map>
    		</property>
    
    		
    		<property name="game">
    			<set>
    				<value>wangzhe</value>
    				<value>lol</value>
    				<value>galname</value>
    			</set>
    		</property>
    
    		
    		<property name="wife">
    			<null></null>
    		</property>
    
    		
    		<property name="infor">
    			<props>
    				<prop key="id">20200802</prop>
    				<prop key="name">cbh</prop>
    			</props>
    		</property>
    	</bean>
    </beans>

**拓展注入**

注意： beans 里面加上这下面两行

使用p和c命名空间需要导入xml约束

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

?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:p="http://www.springframework.org/schema/p"
           xmlns:c="http://www.springframework.org/schema/c"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd">
    
        
        <bean id="user" class="pojo.User" p:name="cxk" p:id="20" >
        </bean>
    
        
        <bean id="user2" class="pojo.User" c:name="cbh" c:id="22"></bean>
    </beans>

**单例模式(默认)**

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5rGk5rGk5rGk5rGk_size_20_color_FFFFFF_t_70_g_se_x_16]

**原型模式: 每次从容器中get的时候，都产生一个新对象！**

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5rGk5rGk5rGk5rGk_size_20_color_FFFFFF_t_70_g_se_x_16 1]

### Bean的自动装配 ###

自动装配是Spring满足bean依赖的一种方式  
Spring会在上下文自动寻找，并自动给bean装配属性

**使用注解实现自动装配**  
1.导入context约束

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

@Autowired  
默认是byType方式，如果匹配不上，就会byName  
在属性上个使用，也可以在set上使用

我们可以不用编写set方法了，前提是自动装配的属性在Spring容器里，且要符合ByName 自动装配

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

@Nullable 字段标记了这个注解，说明该字段可以为空
    public name(@Nullable String name){
        
    
    }

**@Autowired+@Qualifier**  
@Autowired不能唯一装配时，需要@Autowired+@Qualifier

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

public class People {
        
        @Autowired
        private Cat cat;
        @Autowired
        @Qualifier(value = "dog")
        private Dog dog;
        private String name;
    }

如果xml文件中同一个对象被多个bean使用，Autowired无法按类型找到，可以用@Qualifier指定id查找

**@Resource**  
默认是byName方式，如果匹配不上，就会byType

public class People {
        
        Resource(name="cat")
        private Cat cat;
        Resource(name="dog")
        private Dog dog;
        private String name;
    }

**@Resource和@Autowired的区别：**

都是用来自动装配的，都可以放在属性字段上  
@Autowired通过byType的方式实现，而且必须要求这个对象存在！【常用】  
@Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】  
执行顺序不同：@Autowired通过byType的方式实现。@Resource默认通过byname的方式实现

### 使用注解开发 ###

约束

<context:component-scan base-package="com.kuang"/> 
    <context:annotation-config/>
    //@Component 组件
    //等价于<bean id="user" classs"pojo.User"/> 
    @Component
    public class User {
          
         public String name ="秦疆";
    }

属性注入@value

@Component
    public class User {
         
        //相当于<property name="name" value="kuangshen"/> 
        @value("kuangshen") 
        public String name; 
        
        //也可以放在set方法上面
        //@value("kuangshen")
        public void setName(String name) {
         
            this.name = name; 
        }
    }

**衍生**  
@Component有几个衍生注解，会按照web开发中，mvc架构中分层。

dao （@Repository）  
service（@Service）  
controller（@Controller）

**作用域@scope**

//原型模式prototype，单例模式singleton
    //scope("prototype")相当于<bean scope="prototype"></bean>
    @Component 
    @scope("prototype")
    public class User {
         
        
        //相当于<property name="name" value="kuangshen"/> 
        @value("kuangshen") 
        public String name; 
        
        //也可以放在set方法上面
        @value("kuangshen")
        public void setName(String name) {
         
            this.name = name; 
        }
    }

### 使用Java的方式配置Spring ###

要么使用@Bean，要么使用@Component和ComponentScan，两种效果一样

//这里这个注解的意思,就是说明这个类被Spring接管了,注册到了容器中 
    @component 
    public class User {
         
        private String name;
        
        public String getName() {
         
        	return name; 
        } 
        //属性注入值
        @value("QINJIANG')  
        public void setName(String name) {
         
        	this.name = name; 
        } 
        @Override 
        public String toString() {
         
            return "user{" + 
            "name='" + name + '\''+ 
            '}'; 
        } 
    }

//这个也会Spring容器托管,注册到容器中,因为他本米就是一个@Component 
    // @Configuration表这是一个配置类,就像我们之前看的beans.xml，类似于<beans>标签
    @Configuration 
    @componentScan("com.Kuang.pojo") //开启扫描
    //@Import(KuangConfig2.class)
    public class KuangConfig {
         
        //注册一个bean , 就相当于我们之前写的一个bean 标签 
        //这个方法的名字,就相当于bean 标签中的 id 属性 ->getUser
        //这个方法的返同值,就相当于bean 标签中的class 属性 ->User
        
        //@Bean 
        public User getUser(){
         
        	return new User(); //就是返回要注入到bean的对象! 
        } 
    }

@Bean是相当于< bean>标签创建的对象，而我们之前学的@Component是通过spring自动创建的这个被注解声明的对象，所以这里相当于有两个User对象被创建了。一个是bean标签创建的（@Bean），一个是通过扫描然后使用@Component，spring自动创建的User对象，所以这里去掉@Bean这些东西，然后开启扫描。之后在User头上用@Component即可达到spring自动创建User对象了

### 代理模式 ###

**静态代理**

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

**动态代理**  
动态代理的角色和静态代理的一样 .

动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的

动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理

基于接口的动态代理----JDK动态代理  
基于类的动态代理–cglib  
现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist  
我们这里使用JDK的原生代码来实现，其余的道理都是一样的！

**JDK的动态代理需要了解两个类  
核心 : InvocationHandler 和 Proxy ， 打开JDK帮助文档看看  
【InvocationHandler：调用处理程序】**

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

代码实现：

//抽象角色：租房
    public interface Rent {
        
       public void rent();
    }
    Host . java 即真实角色j

//真实角色: 房东，房东要出租房子
    public class Host implements Rent{
        
       public void rent() {
        
           System.out.println("房屋出租");
      }
    }
    ProxyInvocationHandler. java 即代理角色
    
    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);
      }
    
       // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
       // 处理代理实例上的方法调用并返回结果
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
           seeHouse();
           //核心：本质利用反射实现！
           Object result = method.invoke(rent, args);
           fare();
           return result;
      }

//看房
       public void seeHouse(){
        
           System.out.println("带房客看房");
      }
       //收中介费
       public void fare(){
        
           System.out.println("收中介费");
      }
    
    }
    Client . java

//租客
    public class Client {
        
    
       public static void main(String[] args) {
        
           //真实角色
           Host host = new Host();
           //代理实例的调用处理程序
           ProxyInvocationHandler pih = new ProxyInvocationHandler();
           pih.setRent(host); //将真实角色放置进去！
           Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
           proxy.rent();
      }
    
    }

### AOP ###

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

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

**实现AOP**  
前提：导入包

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

**方法一**  
第一种方式  
通过 Spring API 实现  
首先编写我们的业务接口和实现类

public interface UserService {
        
    
       public void add();
    
       public void delete();
    
       public void update();
    
       public void search();
    
    }
    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 search() {
        
           System.out.println("查询用户");
      }
    }

然后去写我们的增强类 , 我们编写两个 , 一个前置增强 一个后置增强

public class Log implements MethodBeforeAdvice {
        
    
       //method : 要执行的目标对象的方法
       //objects : 被调用的方法的参数
       //Object : 目标对象
       @Override
       public void before(Method method, Object[] objects, Object o) throws Throwable {
        
           System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了");
      }
    }
    public class AfterLog implements AfterReturningAdvice {
        
       //returnValue 返回值
       //method被调用的方法
       //args 被调用的方法的对象的参数
       //target 被调用的目标对象
       @Override
       public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        
           System.out.println("执行了" + target.getClass().getName()
           +"的"+method.getName()+"方法,"
           +"返回值："+returnValue);
      }
    }

最后去spring的文件中注册 , 并实现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"
          xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd">
    
       
       <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
       <bean id="log" class="com.kuang.log.Log"/>
       <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    
       
       <aop:config>
           
           <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
           
           <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
           <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
       </aop:config>
    
    </beans>

测试

public class MyTest {
        
       @Test
       public void test(){
        
           ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
           UserService userService = (UserService) context.getBean("userService");
           userService.search();
      }
    }

**方法二**  
自定义类来实现Aop  
目标业务类不变依旧是userServiceImpl

第一步 : 写我们自己的一个切入类

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

去spring中配置

<bean id="diy" class="com.kuang.config.DiyPointcut"/>
    
    
    <aop:config>
       
       <aop:aspect ref="diy">
           <aop:pointcut id="diyPonitcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
           <aop:before pointcut-ref="diyPonitcut" method="before"/>
           <aop:after pointcut-ref="diyPonitcut" method="after"/>
       </aop:aspect>
    </aop:config>

测试：

**方法三**  
使用注解实现

第一步：编写一个注解实现的增强类

package com.kuang.config;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    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.kuang.service.UserServiceImpl.*(..))")
       public void before(){
        
           System.out.println("---------方法执行前---------");
      }
    
       @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
       public void after(){
        
           System.out.println("---------方法执行后---------");
      }
    
       @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
       public void around(ProceedingJoinPoint jp) throws Throwable {
        
           System.out.println("环绕前");
           System.out.println("签名:"+jp.getSignature());
           //执行目标方法proceed
           Object proceed = jp.proceed();
           System.out.println("环绕后");
           System.out.println(proceed);
      }
    }

第二步：在Spring配置文件中，注册bean，并增加支持注解的配置

<bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
    <aop:aspectj-autoproxy/>

### 整合Mybatis ###

1.导入相关jar包

<dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.5.2</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>5.1.10.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>5.1.10.RELEASE</version>
            </dependency>
            
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.9.4</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>2.0.2</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>RELEASE</version>
                <scope>compile</scope>
            </dependency>
        </dependencies>
    
    
        <build>
            <resources>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.properties</include>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>true</filtering>
                </resource>
            </resources>
        </build>

2.pojo

package com.xin.pojo;
    
    import lombok.Data;
    
    @Data
    public class User {
        
        private int id;
        private String key;
        private String psw;
    
    }

3.mybatis 配置文件

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

4.spring配置文件

<?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="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8"/>
            <property name="username" value="root"/>
            <property name="password" value="123456"/>
        </bean>
    
        
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
            
            <property name="configLocation" value="classpath:mybatis.xml"/>
            <property name="mapperLocations" value="classpath:com/xin/mapper/*.xml"/>
        </bean>
    
        
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
            
            <constructor-arg index="0" ref="sqlSessionFactory"/>
        </bean>
    
        <bean id="userMapper" class="com.xin.mapper.UserMapperImpl">
            <property name="sqlSessionTemplate" ref="sqlSession"/>
        </bean>
    
    
    </beans>

5.mapper接口

package com.xin.mapper;
    
    import com.xin.pojo.User;
    
    import java.util.List;
    
    public interface UserMapper {
        
        public List<User> selectUser();
    }

6.mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.xin.mapper.UserMapper">
    
        <select id="selectUser" resultType="User">
            select * from user
        </select>
    
    </mapper>

7.mapperImpl实现类

package com.xin.mapper;
    
    import com.xin.pojo.User;
    import org.mybatis.spring.SqlSessionTemplate;
    
    import java.util.List;
    
    public class UserMapperImpl implements UserMapper{
        
        private SqlSessionTemplate sqlSessionTemplate;
    
        public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
        
            this.sqlSessionTemplate = sqlSessionTemplate;
        }
    
        @Override
        public List<User> selectUser() {
        
            UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
            return mapper.selectUser();
        }
    }

8.测试

import com.xin.mapper.UserMapper;
    import com.xin.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 selectUser() throws IOException {
        
            ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
            UserMapper mapper = (UserMapper) context.getBean("userMapper");
            List<User> user = mapper.selectUser();
            System.out.println(user);
        }
    }

### 事务管理 ###

**编程式事务管理**  
将事务管理代码嵌到业务方法中来控制事务的提交和回滚  
缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

**声明式事务管理**  
一般情况下比编程式事务好用。  
将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。  
将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

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

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

JDBC事务

配置事务通知

<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:method name="search*" propagation="REQUIRED"/>
           <tx:method name="get" read-only="true"/>
           <tx:method name="*" propagation="REQUIRED"/>
       </tx:attributes>
    </tx:advice>

**spring支持7种事务传播行为：**  
propagation\_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。  
propagation\_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。  
propagation\_mandatory：使用当前事务，如果没有当前事务，就抛出异常。  
propagation\_required\_new：新建事务，如果当前存在事务，把当前事务挂起。  
propagation\_not\_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。  
propagation\_never：以非事务方式执行操作，如果当前事务存在则抛出异常。  
propagation\_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation\_required类似的操作

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

**配置AOP**  
导入aop的头文件！

<aop:config>
       <aop:pointcut id="txPointcut" expression="execution(* com.kuang.dao.*.*(..))"/>
       <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    </aop:config>

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5rGk5rGk5rGk5rGk_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/f9beefe634a7445297abd11581657509.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5bCP5rGk5rGk5rGk5rGk,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5rGk5rGk5rGk5rGk_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/d1eb89096c8b430ebbc502995122dcc0.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5bCP5rGk5rGk5rGk5rGk,size_20,color_FFFFFF,t_70,g_se,x_16