Spring学习笔记

最新推荐文章于 2024-07-28 19:41:52 发布

图南zzz

最新推荐文章于 2024-07-28 19:41:52 发布

阅读量443

点赞数 1

分类专栏：后端文章标签： java spring spring 5 xml 后端

本文链接：https://blog.csdn.net/qq_51256566/article/details/121542388

版权

后端专栏收录该内容

7 篇文章 1 订阅

订阅专栏

Spring

一、简介

理念：使现有的技术更加容易使用，本身是一个大杂烩，整合现有的技术框架
SSH：Struct2 + Spring + Hibernate
SSM ：SpringMvc + Spring + Mybatis

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

优点：

Spring是一个开源的免费的框架
是一个轻量级，非入侵式的框架
控制反转(IOC)，面向切面编程(AOP)
支持事务的处理，对框架整合的支持

二、组成

在这里插入图片描述

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

三、IOC理论推导

UserDao 接口

public interface UserDao{
	void getUser();
}

UserDaoImpl 实现类

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

UserService 业务接口

public interface UserService{
    void getUser();
}

UserServiceImpl 业务实现类

public class UserServiceImpl implements UserService{
    
    private UserDao userDao = new UserDaoImpl();
    
    public void getUser(){
        userDao.getUser();
    }
}

原本业务中，用户需求会影响代码，成本代价很大。

使用Set接口实现：

public class UserServiceImpl implements UserService{
    
    private UserDao userdao;

    //利用set进行动态实现值的注入！
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }
    //根据多态，将UserDao的多个实现类，以最终使用时实例化的对象类型注入。
    //满足开闭原则。
    public void getUser(){
        userDao.getUser();
    }
}

IOC本质

控制反转IOC(Inversion of Control)是一种设计思想，DI(依赖注入)是实现IOC的一种方法。也有人认为DI只是IOC的另一种说话，没有IOC的程序中，我们使用面向对象编程，对象的创建与对象的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三发那个。

所谓控制反转就是：获得依赖对象的方式反转了

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

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

HelloSpring

配置XML文件——ApplicationContext.xml，这里简写为Beans.xml

<beans	官方配置>
    <!-- 使用Spring来创建对象，在Spring这些都称为Bean 
		类型 变量名 = new (类型);
		Hello hello = new Hello();
		
		id = 变量名   class = new 的对象  property 相当于给对象中的属性设置一个值
	-->
    <bean id="hello" class="com.tunan.pojo.Hello">
    	<property name="str" value="Spring"/>
    </bean>
</beans>

测试类

public class MyTest{
    public static void main(String[] args){
        //获取Spring的上下文对象
        //这句话是写死的，都是这样的，里面可以传两个参数，通过配置文件读取
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toSring());
        
    }
    
}

实体类

public class Hello{
    
    private String str;
    
    public Sring getStr(){
        return str;
    }
    //核心是调用set函数，来设置str的值实现new
    public void setStr(String str){
        this.str = str;
    }
    
    @Override
    public String toString(){
        return "Hello{" +
            "str=" + str +'}';
    }
}

修改之前的代码

<beans	官方配置>
    <bean id="mysqlImpl" class="com.tunan.pojo.UserDaoMysqlImpl"/>
    <bean id="oracleImpl" class="com.tunan.pojo.UserDaoOracleImpl"/>
    <bean id="UserServerImpl" class="com.tunan.pojo.UserServiceImpl">
    	<!-- ref：引用Spring容器中创建好的对象
			vaule：具体的值，数据类型！-->
        <property name="userDao" ref="mysqlImpl"/>
    </bean>
    <bean id="mysqlImpl" class="com.tunan.pojo.UserDaoMysqlImpl"/> 
    <!-- 修改的时候只需要修改这里的class就可以了 --> 
</beans>

public class MyTest{
    public static void main(Sting[] args){
        //获取ApplicationContext:拿到Spring的容器，参数可以输入多个xml，用","隔开
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //需要什么就get什么
        UserServiceImpl userServiceImpl = (UserServiceImpl)context.getBean("UserServiceImpl");
        
        userServiceImpl.getUser();
    }
}

//如果要改的话就只需要改用户文件就可以了

四、IOC创建的对象的方式

默认无参构造

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

有参构造方式

<beans >
    <!-- 第一种方式：下标赋值 -->
	<bean id="user" class="com.kuang.pojo.User">
    	<constructor-arg index="0" value="TuNan"/>
    </bean>
    <!-- 第二种方式：类型赋值 
		不推荐使用，如果同一个类型有好几个参数就不行了  -->
	<bean id="user" class="com.kuang.pojo.User">
    	<constructor-arg type="java.lang.String" value="TuNan"/>
    </bean>
    <!-- 第三种方式：参数名赋值 -->
	<bean id="user" class="com.kuang.pojo.User">
    	<constructor-arg name="name" value="TuNan"/>
    </bean>
</beans>

五、Spring配置说明

5.1 别名

<alias name="user" alias="newName"/>
<!-- 在测试类中就可以用context.getBean("newName")代替context.getBean("user")了-->

5.2 Bean的配置

<bean id="user" class="com.tunan.pojo.User" name="newName" >
	<property name="name" value="TuNan"/>
</bean>
<!-- id: bean的唯一标识符，也就是对象名
	class: bean对象所对应的全限定名：包名 + 类型
	name: 别名,可以同时取多个别名，用","隔开

5.3 import

一般用于团队开发使用，可以将多个配置文件，导入合并为一个总的ApplicationContext.xml。

如果配置文件中的bean重名，则下面会覆盖上面的。

<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>

六、DI(依赖注入)

6.1 构造器注入(见上文)

6.2 Set方式注入(重点)

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

【环境搭建】

复杂类型

public class Address{
    private String address;
    public String getAddress(){实现}
    public void serAddress(String address){
        this.address = address;
    }
}

真实测试对象

public class Student{
	private String name;
	private Address addresss;
	private String[] books;
	private List<String> hobbies;
	private Map<String,String> card;
	private Set<String> games;
	private String girlfriend;
	private Properties info;
}

beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans 官方配置>
    <bean id="address" class="com.tunan.pojo.Address">
    	<property name="address" value="温州"/>
    </bean>
	<bean id="student" class="com.kuang.pojo.Student">
    	<!-- 第一种，普通值注入,value -->
        <property name="name" value="TuNan"/>
        <!-- 第二种，Bean注入,ref -->
        <property name="address" ref="address"/>
        </property>
        <!-- 第三种，array数组注入 -->
        <property name="books">
        	<array>
            	<value>红楼梦</value>
                <value>西游记</value>
                <value>水浒传</value>
                <value>三国演义</value>
            </array>
        </property>
         <!-- 第四种，List数组注入 -->
        <property name="hobbies">
        	<list>
            	<value>听歌</value>
                <value>打球</value>
            </list>
        </property>
        <!-- 第五种，Map注入 -->
        <property name="hobbies">
        	<Map>
            	<entry key="身份证" value="asdasdasd"/>
                <entry key="银行卡" value="3543216546354"/>
            </Map>
        </property>
         <!-- 第六种，Set注入 -->
        <property name="games">
        	<set>
            	<value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>
        <!-- 第七种，null -->
        <property name="girlfriend">
        	<null/>
        </property>
        <!-- 第八种，Properties -->
        <property name="info">
        	<props>
            	<prop key="driver">2020214586</prop>
                <prop key="username">root</prop>
            </props>
        </property>
    </bean>
</beans>

<!-- 输出：
Student{
	name='TuNan',
	address=Address{address="温州"},
	books=[红楼梦,西游记,水浒传,三国演义],
	hobbies=[听歌,打球],
	card={
		身份证=asdasdasd,
		银行卡=3543216546354
	},
	games=[LOL,COC,BOB],
	girlfriend='null',
	info={
		driver=2020214586,
		username=root
	}
}

测试类

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

6.3 拓展方式注入

p命名空间注入，可以直接注入属性

在beans官方配置中加入P命名空间配置

<!-- p所代表的也就是peoperty -->
<bean neme="user" class="com.tunan.pojo.User" p:name="TuNan" p:age="18" p:pouse-ref="引用bean"/>

c命名空间注入

在beans官方配置中加入c命名空间配置

<!-- C命名空间注入,通过构造器注入：construct-args -->
<bean neme="user" class="com.tunan.pojo.User" c:age="18" c:name="TuNan"/>

注意点：不能直接使用，要去导入xml约束

6.4 bean的作用域

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

单例模式(Spring默认机制)

<bean neme="user" class="com.tunan.pojo.User" c:age="18" c:name="TuNan" scope="singleton"/>
<!-- 测试类中get到的是同一个对象  -->

原型模式

<bean neme="user" class="com.tunan.pojo.User" c:age="18" c:name="TuNan" scope="prototype"/>
<!-- 测试类中get到的都是一个新对象  -->

其余的request、session、application、websocket，只有在web开发中能够使用。

七、Bean的自动装配

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

Spring有三种装配的方式

在xml显式装配
在java中显式装配
隐式的自动装配

7.1 byName自动装配

<bean id="cat" class="com.tunan.pojo.cat"/>
<bean id="dog1" class="com.tunan.pojo.dog"/>
<!-- byName会自动在容器上下文查找，和自己对象set方法后面的值对应的beanId  -->
<bean id="people" class="com.tunan.pojo.People" autuwire="byName">
	<property name="name" value="TuNan"/>
</bean> 
<!-- 因此这样只会自动创建猫，不会自动创建狗  -->

7.2 byType自动装配

<bean class="com.tunan.pojo.cat"/>
<bean class="com.tunan.pojo.dog"/>
<!-- byType会自动在容器上下文查找，和自己对象属性类型相同的bean  -->
<bean id="people" class="com.tunan.pojo.People" autuwire="byName">
	<property name="name" value="TuNan"/>
</bean> 
<!-- 因此即使不给bean设置id,也可以自动装配  -->

小结：

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

7.3 使用注解实现自动装配

jdk1.5支持的注解，Spring2.5开始支持注解

要使用注解须知：

导入约束：context约束
配置注解的支持：context:annotation-config/

<beans 约束>
    <!-- id需要和属性名一样 -->
    <bean id="cat" class="com.tunan.pojo.Cat"/>
    <bean id="dog" class="com.tunan.pojo.Dog"/>
    <bean id="people" class="com.tunan.pojo.People"/>
    <context:annotation-config/>
</beans>

实现类：

public class People{
	@Autowired //写注解
	private Dog dog;
    @Autowired //写注解
	private Cat cat;
    @Autowired //写注解
    private String name;
}

@Autowired 一般用这个就够了

在使用属性上使用即可，也可以在set方式上使用。

使用Autowired可以不编写Set方法了，前提是这个自动装配的属性在IOC(Spring)容器中存在，且符合名字byName。

//加上@Nullable之后，即使为空也不报错
public People(@Nullable String name){
	this.name = name;
}

//如果显式定义了Autowired的required属性为false，即使为空也不会报错
@Autowired(required = false)
private Cat cat;

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

还可以使用@Resource来指定byName

//如果在xml中有多个对象，也可以通过@Resource的name属性来对应相应的属性
@Resource(name="cat2")
private Cat cat;

小结：

@Resource和@Autowired的区别：

都是用来自动装配的，都可以放在属性字段上。
@Autowired通过bytype的方式实现，而且必须要求这个对象存在(或者手动设置可以不存在)【常用】
@Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现。
执行顺序不同：@Autowired先类型后名字，@Resource先名字后类型

八、使用注解开发

在Spring4之后，在使用注解的时候，必须要导入一个aop的包。

使用注解需要增加注解的约束，获得注解的支持。

bean

<?xml version="1.0" encoding="UTF-8"?>
<beans 约束>
	<!-- 指定要扫描的包，这个包下的注解就会生效 -->
	<context:component-scan base-package="com.tunan.pojo"/>
    <context:annotation-config/>
</beans>

//等价于 <bean id="user" class="com.tunan.pojo.User"/>
@Component
public class User{
    public String name = "TuNan";
}

public class MyTest{
    public static void main(String[] args){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = (User)context.getBean("user"); //bean默认就是类型的小写
        System.out.println(user.name);
    }
}

属性如何注入

//等价于 <bean id="user" class="com.tunan.pojo.User"/>
@Component
public class User{
    //复杂的还是要在配置文件里面写，比如数组等。
    //相当于<property name="name" value="TuNan"/>
    @Value("TuNan")
    public String name;
}

衍生的注解

@Component有几个衍生注解，在web开发中，会按照mvc三层架构分层。
- dao 【@Repository】
- service 【@Service】
- controller 【@Controller】
这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean。
自动装配
- Autowired : 自动装配通过类型，名字。
  
  如果Autowired不能唯一自动装配到属性，则需要通过@Qualifier(value=“xxx”)。
- @Nullable : 字段标记了这个注解，说明这个字段可以为null。
- @Resource ：自动装配通过名字，类型。
作用域

@Scope
- 单例模式 @Scope(“singleton”)
- 原型模式 @Scope(“prototype”)
小结

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

<?xml version="1.0" encoding="UTF-8"?>
<beans 约束>
	<!-- 指定要扫描的包，这个包下的注解就会生效 -->
	<context:component-scan base-package="com.tunan.pojo"/>
    <context:annotation-config/>
</beans>

九、使用JavaConfig实现配置

完全不适用xml配置，全权交给Java来做，JavaConfig是Spring的一个子项目，在Spring4之后，九成为了一个核心功能。

//这个注解就是说这个类被Spring接管了，注册到了容器中
@Component
public class User{
    private String name;
    
    public String getName(){
        return name;
    }
    
    @Value("TuNan")//属性值注入
    public void setName(String name){
        this.name = name;
    }
}

// 这个也会被Spring容器托管，注册到容器中，因为他本来就是一个@Component
// @Configuration代表这是一个配置类，就类似于之前的beans.xml
@Configuration
@ComponentScan("com.tunan.pojo")
@Import(TuNanconfig2.class)
public class TuNanConfig{
    //注册一个bean,相当于bean标签
    //方法名，对应bean标签的id属性
    //方法返回值,对应bean标签class属性
    @Bean
    public User user(){
        return new User();   //就是返回要注入到bean的对象
    }
}

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

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

十、代理模式

代理模式是SpringAOP的底层。【SpringAOP 和 SpringMVC】

代理模式分类

静态代理
动态代理

10.1 静态代理

角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，一般做一些附属操作
- 客户：访问代理对象的人
优势：
- 可以使真实角色的操作更加纯粹，不用去关注公共业务
- 公共业务交给代理角色，实现了业务的分工
- 公共业务发生拓展的时候，方便集中管理
缺点：
- 一个真实角色产生一个代理角色，代码量翻倍
代码步骤：
1. 接口
2. 真实角色
3. 代理角色
4. 客户端访问代理角色

在这里插入图片描述

10.2 动态代理

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

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

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);
    }
    
    //处理代理实例，并返回结果
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
       //动态代理的本质，就是使用反射机制实现。
        seeHouse();
        Object result = method.invoke(rent,args);
        fare();
        return result;
    }
}

public class Client{
    public static void main(String[] args[]){
        //真实角色
        Host host = new Host();
        
        //代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        
        //通过调用程序处理角色来处理我们要调用的接口对象
        pih.setRent(host);//设置要代理的对象
        Rent proxy = (Rent)pih.getProxy(); //Proxy就是动态生成的。
        proxy.rent();
    }
}

十一、AOP

11.1 简介

AOP(Aspect Oriented Programming)面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合降低，提可复用率。

在这里插入图片描述

11.2 AOP在Spring中的作用

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

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

在这里插入图片描述

11.3 使用Spring AOP需要导包

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

11.4 方式一：使用Spring的API接口

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

public class AfterLog implements MethodReturningAdvice{
    //returnValue:返回值
    //method : 要执行目标对象的方法
    //args : 参数
    //target : 目标参数
    public void before(Object returnValue,Method method,Object[] args,Object target) throws Throwable{
        System.out.println("执行力"+method.getName()+"方法，返回结果为"+returnValue);
    }
}

<?xml --- ?>
<beans --->
    <!-- 注册bean -->
	<bean id="userService" class="com.tunan.service.UserServiceImpl"/>
    <bean id="log" class="com.tunan.log.Log"/>
    <bean id="afterLog" class="com.tunan.log.AfterLog"/>
    <!-- 配置aop,需要导入aop的约束 -->
    <aop:config>
    	<!--切入点:expression:表达式，execution(要执行的位置)-->
        <aop:pointcut id="pointcut" expression="excution(* com.tunan.service.UserServiceImpl.*(..))"/>
        
        <!-- 执行环绕增强 -->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
    
</beans>

public class Mytest{
    public static void main(String args[]){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口，不是实现类
        UserService userServic = (UserService)context.getBean("userService");
        
        userService.add();
    }
}

11.5 方式二自定义切面类(包含各种切入点函数)

<?xml --- ?>
<beans --->
    <!-- 注册bean -->
	<bean id="userService" class="com.tunan.service.UserServiceImpl"/>
    <bean id="log" class="com.tunan.log.Log"/>
    <bean id="afterLog" class="com.tunan.log.AfterLog"/>
    <bean id="diy" class="com.kuang.diy.DiyPointCut"/>
    <!-- 配置aop,需要导入aop的约束 -->
    <aop:config>
    	<!--切入点:expression:表达式，execution(要执行的位置)-->
        <aop:aspect ref="diy">
            <!-- 引入一个类，调用类中的两个函数 -->
        	<aop:pointcut id="point" expression="excution(* com.tunan.service.UserServiceImpl.*(..))"/>
            <aop:before method="before" pointcut-ref="point"/>
            <aop:before method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
</beans>

11.6 使用注解实现AOP

@Aspect	//标注这个类是一个切面
public class AnnotationPointCut{
    @Before("excution(* com.tunan.service.UserServiceImpl.*(..))")
    pulic void before(){
        System.out,println("方法执行前=====");
    }
    @After("excution(* com.tunan.service.UserServiceImpl.*(..))")
    pulic void before(){
        System.out,println("方法执行后=====");
    }
    @Around("excution(* com.tunan.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable{
        System.out.println("环绕前");
        Signature signature = jp.getSignature(); //获得签名
        System.out.println("signature:" + signature);
        Object proceed = jp.proceed(); //执行方法
        System.out.println("环绕后");
    }
}

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

十二、整合Mybatis

步骤：

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

12.1 mybatis-spring

配置spring-dao.xml

<?xml ... ?>
<beans ...>
    
    <!-----------------------  这些都是固定的配置方式 ----------------------------->
	<!-- DataSource：使用Spring的数据源代替Mybatis的配置 c3p0 dbcp druid 
			这里用Spring提供的JDBC-->
    <bean id="datasource" class="org.springfarmwork.jdbc.datasource.DriverManagerDataSource">
    	<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc://localhost:3306/mybatis?useSSL=true......"/>
        <property name="username" value="root"/>
        <property name="password" value="12456"/>
    </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/tunan/mapper/*.xml"/>
    </bean>
    <!-- SqlSessionTemplate:就是使用的sqlSesion -->
    <bean id="sqlSesion" class="org.mybatis.spring.SqlSessionTemplate">
    	<!-- 只能使用构造器注入sqlSessionFactory，因为没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
    <!---------------------------  到这里为止  ----------------------------->
    
    <!---->
    <bean id="userMapper" class="com.tunan.mapper.UserMapperImpl">
    	<property name="sqlSession" ref="sqlSession"/>
    </bean>
</beans>

在Mybatis中的操作用sqlSession执行，在这里都用SqlSessionTemplate

//接口实现类
public class UserMapperImpl implements UserMapper{
    
    private SqlSessionTemplate sqlSession;
    
    public void setSqlSession(SqlSessionTemplate sqlSession){
        this.sqlSession = sqlSession;
    }
    public List<User> selectUser(){
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

applicationContext.xml

<?xml ... ?>
<beans ...>
    <!-- 固定的配置直接导入就行，这里面只要写程序的内容 -->
	<import resource="spring-dao.xml"/>
    <!---->
    <bean id="userMapper" class="com.tunan.mapper.UserMapperImpl">
    	<property name="sqlSession" ref="sqlSession"/>
    </bean>
</beans>

UserMapper.xml

<?xml ...?>
<!DOCTYPE mapper ...>
	<mapper namespace="com.tunan.mapper.UserMapper">
		<select id="selecUser" resultType="user">
        	select * from mybatis.user;
        </select>
	</mapper>
</mapper>

12.2 SqlSessionDaoSupport

这是一个抽象的支持类，用来提供SqlSession，调用getSqlSession()方法会得到一个SqlSessionTemplate，之后可以用于执行SQL方法。

//要继承SqlSessionDaoSupport类
public class USerMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
    public List<User> selectUser(){
        SqlSession sqlSession =  getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

<?xml ... ?>
<beans ...>
    <bean id="datasource" class="org.springfarmwork.jdbc.datasource.DriverManagerDataSource">
    	<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc://localhost:3306/mybatis?useSSL=true......"/>
        <property name="username" value="root"/>
        <property name="password" value="12456"/>
    </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/tunan/mapper/*.xml"/>
    </bean>
    <!-- 用这种方式的话，这一步可以省略↓ -->
    <bean id="sqlSesion" class="org.mybatis.spring.SqlSessionTemplate">
    	<!-- 只能使用构造器注入sqlSessionFactory，因为没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
	<!-- 用这种方式的话，这一步可以省略↑ -->
    
    <bean id="userMapper2" class="com.tunan.mapper.UserMapperImpl2">
    </bean>
</beans>

十三、声明式事务

13.1 事务

把一组业务当作一个业务来做，要么都成功，要么都失败
确保完整性和一致性
事务的ACID原则：
- 原子性
- 一致性
- 隔离性
  - 多个业务可能操作同一个资源，放置数据损坏
- 持久性
  - 事务一旦提交，无论系统发生什么问题，结果都不会被影响，被持久化写道存储器中
用途

防止一个方法中同时操作了增删改查多个操作的时候，前几个操作执行成功了，但是有操作执行失败，导致逻辑和数据混乱。

13.2 spring中的事务管理

声明式事务：AOP
编程式事务：

<?xml ... ?>
<beans ...>
    <bean id="datasource" class="org.springfarmwork.jdbc.datasource.DriverManagerDataSource">
    	<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc://localhost:3306/mybatis?useSSL=true......"/>
        <property name="username" value="root"/>
        <property name="password" value="12456"/>
    </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/tunan/mapper/*.xml"/>
    </bean>
    <!-- 用这种方式的话，这一步可以省略↓ -->
    <bean id="sqlSesion" class="org.mybatis.spring.SqlSessionTemplate">
    	<!-- 只能使用构造器注入sqlSessionFactory，因为没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
	<!-- 用这种方式的话，这一步可以省略↑ -->
    
    
    <!-- 配置声明式事务 -->
    <bean id="transactionManager" class="com.springframeword.jdbc.datasource.DataSourceTransactionManager">
    	<constructor-arg ref="dataSource"/>
    </bean>
    
    <!-- 结合AOP实现事务的注入 -->
    <!-- 配置事务通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 定义要给哪些方法配置事务 -->
        <!-- 配置事务的传播特性：propagation属性 -->
    	<tx:attributes>
        	<tx:method name="add"/>
            <tx:method name="delete"/>
            <tx:method name="update"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
</beans>

图南zzz

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring学习笔记

Spring一、简介理念：使现有的技术更加容易使用，本身是一个大杂烩，整合现有的技术框架SSH：Struct2 + Spring + HibernateSSM ：SpringMvc + Spring + Mybatis<dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <versio
复制链接

扫一扫