Spring学习笔记

不哦罗密经

已于 2024-06-06 13:54:50 修改

阅读量778

点赞数 16

文章标签： spring 学习笔记

于 2024-03-29 20:55:05 首次发布

本文链接：https://blog.csdn.net/b810411/article/details/137111312

版权

一.spring是什么

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器(框架)。

首先，控制反转是什么意思？

控制反转通俗讲就是平常我们new一个实例，这个实例的控制权是我们程序员，而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做。

举个例子

1.UserDao

public interface UserDao {
    public void add(User user);
    public  User select(int id);
}

2.UserDaoImp

public class UserDaoImp implements UserDao
{
    @Override
    public void add(User user) {
        System.out.println("添加成功1");
    }

    @Override
    public User select(int id) {
        System.out.println("查询成功1");
        return null;
    }
}

3.UserService

public interface UserService {
    public void add(User user);
    public User select(int id);

}

4.UserServiceImp

public class UserServiceImp implements UserService{
    private UserDaoImp userDao=new UserDaoImp();
    @Override
    public void add(User user) {
        userDao.add(user);
    }

    @Override
    public User select(int id) {
        userDao.select(id);
        return null;
    }
}

5.测试

public class UserTest {
    public static void main(String[] args) {
        UserService userService=new UserServiceImp();
        User select = userService.select(1);
    }
}

现在我们增加一个UserDao实现类

public class UserDaoImp2 implements UserDao {
    @Override
    public void add(User user) {
        System.out.println("添加成功2");
    }

    @Override
    public User select(int id) {
        System.out.println("查询成功2");
        return null;
    }
}

我们想要使用这个实现类时，需要改动UserServiceImp中的代码。如果我们有很多这种实现类，那就需要大量修改，是很不方便的。

所以我们可以采用set方法，得到UserDao,而不是把它写死在代码里。

public class UserServiceImp implements UserService{
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao=userDao;
    }
    @Override
    public void add(User user) {
        userDao.add(user);
    }

    @Override
    public User select(int id) {
        userDao.select(id);
        return null;
    }
}

测试类

public class UserTest {
    public static void main(String[] args) {
        UserServiceImp userServiceImp = new UserServiceImp();
        userServiceImp.setUserDao(new UserDaoImp2());
        userServiceImp.select(1);
    }
}

这个就是IoC的原型，我们不用在业务代码中修改内容，而是通过set方法创建对象。

这里给出一个较精准的定义：(先有个印象)

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

面向切面(AOP)又是什么意思呢？

首先我们要知道aop的原理就是动态代理，可以看代理模式笔记，详细了解。

简单来说，aop就是动态代理，我们把新增加的功能由代理类实现。可以使程序员专注于业务逻辑，分层更加明确。

二.spring的使用

1.导包

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

2.编写实体类

@Data
@AllArgsConstructor
public class Hello {
    public Hello() {
        System.out.println("Hello被创建");
    }
    private String str;
}

3.编写核心文件 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
        https://www.springframework.org/schema/beans/spring-beans.xsd">


    <!--使用Spring来创建对象，在Spring这些都称为Bean
    类型 变量名 = new 类型();
    Hello hello = new Hello();

    id = 变量名   class = new的对象
    property 相当于给对象中的属性设置一个值！
    -->
   <bean id="hello" class="com.yang.study.pojo.Hello">
       <property name="str" value="spring"/>
   </bean>

</beans>

3.测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);
    }
}

三. 配置文件

1.alias (别名)

2.bean 及其属性

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

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

class是bean的全限定名=包名+类名

scope作用域，默认是单例模式singleton，也可以设置为多例模式prototype

-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

<bean id="hello" class="com.yang.study.pojo.Hello" scope="prototype">
       <property name="str" value="spring"/>
</bean>
<bean id="hello2" class="com.yang.study.pojo.Hello2" scope="singleton">
        <property name="str" value="hello2"/>
</bean>

bean中的property相当于给对象中的属性设置一个值
property中的属性name,其值并不是属性 , 而是set方法后面的那部分 , 首字母小写
当set的是基本类型时，赋值用valuse
当set的是一个类时，引用另外一个bean , 不是用value 而是用 ref

[注意]getBean 得到的是配置文件中所有的Bean对象，会先把所有bean对象都实例化，然后指定具体是哪个，取出来，所以用同一个id取出来的肯定都是同一个对象，这是在scope默认为singleton时。我们将scope设置为prototype，取bean时就会新创建一个对象。

public class Test {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
      
        Hello hello = (Hello) context.getBean("hello");
        Hello hello2= (Hello) context.getBean("hello");
        Hello2 hello21 = context.getBean("hello2", Hello2.class);
        Hello2 hello22 = context.getBean("hello2", Hello2.class);
        System.out.println(hello==hello2); //false由于采用的是多例所以对象不是一个
        System.out.println(hello21==hello22);//true由于采用的是单例所以对象是一个
        System.out.println(hello);
    }

}

3.import

四.依赖注入

1.构造器注入

(1) 无参构造

实体类

@Data
@AllArgsConstructor
public class Hello {
    public Hello() {
        System.out.println("Hello被创建");
    }
    private String str;
}

beans.xml

 <bean id="hello" class="com.yang.study.pojo.Hello">
       <property name="str" value="spring"/>
 </bean>

测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
       //在执行getBean的时候, user已经创建好了 , 通过无参构造
        Hello hello = (Hello) context.getBean("hello");
    }
}

(2) 有参构造

实体类

@Data
public class Hello {
    public Hello() {
        System.out.println("Hello被创建");
    }

    public Hello(String str, int id) {
        this.str = str;
        this.id = id;
        System.out.println("Hello构造器12");
    }

    public Hello(String str) {
        this.str = str;
        System.out.println("Hello构造器1");
    }

    private String str;
    private int id;

}

beans.xml 有三种方式(掌握第一种即可)

    <!-- 第一种根据index参数下标设置 -->
    <bean id="hello1" class="com.yang.study.pojo.Hello">
        <constructor-arg index="0" value="sp"/>
        <constructor-arg index="1" value="2"/>
    </bean>
    <!-- 第二种根据参数名字设置 -->
    <bean id="hello" class="com.yang.study.pojo.Hello">
        <constructor-arg name="id" value="2"/>
        <constructor-arg name="str" value="sp"/>
    </bean>
    <!-- 第三种根据参数类型设置 -->
    <bean id="hello2" class="com.yang.study.pojo.Hello">
        <constructor-arg type="java.lang.String" value="sp"/>
        <constructor-arg type="int" value="1"/>
    </bean>

2.Set 注入

要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is .

3.基于注解的注入-自动装配模式

结论：

@Autowired
根据类型进行注入（byType），如果同一类型的Bean有多个，尝试根据名字进行二次匹配，名字默认是类名首字母小写的id，没有找到报错；加上了@Qualifier直接按这上面的value找id
@Qualifier 用这个指定name,不能单独使用
@Resourse 先用byName(直接指定value={name}),再用byType(了解)

应用：

注解本质上也是上述注入方式的简约方式，我们先用上述方式写个例子，看哪里被注解取代了

实体类

public class Cat {
    private String name;
    private int age;
    public void shot() {
        System.out.println(this.name+"喵喵叫");
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

public class Dog {
    private String name;
    private int age;
    public void shot() {
        System.out.println(this.name+"汪汪叫");
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

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

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

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

    public Cat getCat() {
        return cat;
    }

    public Dog getDog() {
        return dog;
    }
}

beans.xml

    <bean id="cat" class="com.yang.pojo.Cat">
        <property name="age" value="6"/>
        <property name="name" value="花花"/>
    </bean>
    <bean id="dog" class="com.yang.pojo.Dog">
        <property name="name" value="豆豆"/>
        <property name="age" value="5"/>
    </bean>
    <bean id="user" class="com.yang.pojo.User">
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
    </bean>

测试

public class test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = context.getBean("user", User.class);
        user.getDog().shot();
        user.getCat().shot();
    }
}

现在，我们采用注解方式来进行注入

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

1、在spring配置文件中引入context文件头

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

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

2、开启属性注解支持！

<context:annotation-config/>

测试：

1.将User类中的set方法去掉，使用@Autowired注解

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

    public Cat getCat() {
        return cat;
    }

    public Dog getDog() {
        return dog;
    }
}

2.此时配置文件内容

    <bean id="cat" class="com.yang.pojo.Cat">
        <property name="age" value="6"/>
        <property name="name" value="花花"/>
    </bean>
    <bean id="dog" class="com.yang.pojo.Dog">
        <property name="name" value="豆豆"/>
        <property name="age" value="5"/>
    </bean>
    <bean id="user" class="com.yang.pojo.User"/>

五.注解开发

结论：

1.1 @Component(" XXX ")
加在类上
相当于<bean id=" XXX " class=" 当前注解的类 "/>
括号里面的值相当于id,若不写默认为类名称首字母小写

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

@Controller:controller层
@Service：service层
@Repository:dao层

2.@value(“值”)
可以加在属性上面，也可以加在set方法上面
相当于配置文件中 <property name="name" value="值"/>

3.@scope("作用域")
加在类上

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

4.基于Java类进行配置

我们可以完全抛弃掉beans.xml文件

1、新建一个config配置包，编写一个MyConfig配置类

@Configuration  //代表这是一个配置类
public class MyConfig {

   @Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
   public Dog dog(){
       return new Dog();
  }

}

3、测试

@Test
public void test2(){
   ApplicationContext applicationContext =
           new AnnotationConfigApplicationContext(MyConfig.class);
   Dog dog = (Dog) applicationContext.getBean("dog");
   System.out.println(dog.name);
}

应用：

还是基于上面的案例进行应用。

准备工作：

1.使用注解开发配置文件要有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">

</beans>

2.开启注解

<context:component-scan base-package="com.yang.pojo"/>

注：这个是设置是扫包，来看哪个包下有bean实体类的注解
与上面的 <context:annotation-config> 是不一样的。

简述区别就是

<context:annotation-config> 是支持value,Autowired,Qualifier等注解
而 <context:component-scan> 支持 <context:annotation-config> 支持的所有注解，并且支持@Component等实体类注解

具体可以看下面链接

XML中context:annotation-config和context:component-scan简述

测试：

把beans.xml中的所有配置都变为注解

@Component
public class Cat {
    @Value("花花")
    private String name;
    private int age;
    public void shot() {
        System.out.println(this.name+"喵喵叫");
    }

    public void setName(String name) {
        this.name = name;
    }
    @Value("6")
    public void setAge(int age) {
        this.age = age;
    }
}

@Component
public class Dog {

    @Value("豆豆")
    private String name;
    @Value("5")
    private int age;
    public void shot() {
        System.out.println(this.name+"汪汪叫");
    }

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

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

@Component("user")
public class User {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;

    public Cat getCat() {
        return cat;
    }

    public Dog getDog() {
        return dog;
    }
}

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

    <context:component-scan base-package="com.yang.pojo"/>

</beans>

六.AOP

思想就是动态代理：动态代理

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

以下名词需要了解下：

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

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

使用Spring实现Aop：(自定义切面) 【推荐第二种】

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

1.通过 Spring API 实现

前置通知/后置通知/环绕通知... -> 切点pointcut(方法)

1.写service接口和实现类

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

public class StudentServiceImp implements StudentService{
    @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 AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("调用了"+o1.getClass().getName()+"的"+method.getName()+"方法,并且返回了"+o);
    }
}

public class Log implements MethodBeforeAdvice {

    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+"的"+method.getName()+"方法被执行");
    }
}

3.最后去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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">


    <bean id="studentService" class="com.yang.service.StudentServiceImp"/>
    <bean id="afterLog" class="com.yang.proxy.AfterLog"/>
    <bean id="log" class="com.yang.proxy.Log"/>

    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(public void com.yang.service.StudentServiceImp.*(..))"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

2.自定义类来实现Aop

切面(类) -> 切点pointcut(方法) -> 切面里的每一个通知是在切点得哪个地方执行

1.写一个我们自己的切入类

@Component("diy")
public class MyLog {
    public void before(JoinPoint joinPoint) {
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法执行前");
    }
    public void after() {
        System.out.println("方法执行后");
    }
}

2.去spring中配置

 <aop:config>
        <aop:aspect ref="diy">
            <aop:pointcut id="pointcut" expression="execution(* com.yang.service.StudentServiceImp.*(..))"/>
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

3.使用注解实现

1.注解增强类

@Component("diy")
@Aspect
public class MyLog {
    @Before("execution(* com.yang.service.StudentServiceImp.*(..))")
    public void before(JoinPoint joinPoint) {
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法执行前");
    }
    @After("execution(* com.yang.service.StudentServiceImp.*(..))")
    public void after() {
        System.out.println("方法执行后");
    }
    @Around("execution(* com.yang.service.StudentServiceImp.*(..))")
    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);
    }
}

2.在配置中开启aop注解

<aop:aspectj-autoproxy/>

声明式事务的实现

数据库的操作是由Mybatis来操作的，我们先来回顾一下Mybatis，将Mybatis和Spring整合

Mybatis-Spring整合

史上最详细mybatis与spring整合教程-CSDN博客参考

1.导包

spring相关

注意：

把spring-jdbc导入，dataSource的类在这个包下
也要注意 jdbc和mvc的版本要一致，否则后面报错误
java.lang.NoSuchMethodError: org.springframework.beans.factory.config.BeanDefinition.getResolvableType()Lorg/springframework/core/ResolvableType;

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

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

整合需要的包（重要）

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

2.固定步骤

Mybatis得到SqlSession得步骤为:DataSource->SqlSessionFactoryBuilder -> SqlSessionFactory -> SqlSession

spring得到SqlSession得步骤为: DataSource -> SqlSessionFactoryBean -> SqlSessionTemplate

DataSource

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123"/>
    </bean>

SqlSessionFactoryBean

SqlSessionFactory是mybatis的核心，当与spring进行整合时，我们使用mybatis-spring提供的SqlSessionFactoryBean 来创建其实例，SqlSessionFactoryBean实现了FactoryBean 接口。SqlSessionFactoryBean的配置有2种风格：

保留mybatis的核心配置文件
不保留mybatis的核心配置文件

(1) 保留mybatis的核心配置文件

在mybatis-config.xml文件中并没有配置<environment>、<dataSource>、<transactionManager>等元素。即使配置了，也会被SqlSessionFactoryBean忽略。我们需要显式的为SqlSessionFactoryBean的dataSource属性引用一个数据源配置，如果不指定，在其初始化时就会抛出异常。通过configLocation属性，指定mybatis核心配置文件的路径。

mybatis的配置依然保留在mybatis的核心配置文件mybatis-config文件中，以下是一个示例：

<configuration>
    <typeAliases>
        <package name="com.yang.pojo"/>
    </typeAliases>
    <mappers>
        <mapper resource="com/yang/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--数据源配置-->
        <property name="dataSource" ref="dataSource"/>
        <!--通过configLocation属性指定mybatis核心配置文件mybatis-config.xml路径-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

(2) 不保留mybatis的核心配置文件

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--相当于别名--> 
        <property name="typeAliasesPackage" value="com.yang.pojo"/>
        <!--从类路径下加载在mybatis/mappers包和它的子包中所有的 MyBatis 映射器 XML 文件-->
        <!-- 相当于Mapper注册 -->
        <property name="mapperLocations" value="classpath*:com/yang/mapper/**/*.xml"/>
        <!--相当于settings-->
        <property name="configuration">
            <bean class="org.apache.ibatis.session.Configuration">
                <property name="mapUnderscoreToCamelCase" value="true"/>
                <property name="cacheEnabled" value="true"/>
                <property name="defaultExecutorType" value="SIMPLE"/>
            </bean>
        </property>
    </bean>

SqlSessionTemplate

SqlSessionTemplate 是 mybatis-spring 的核心，其实现了SqlSession接口，且线程安全。使用了SqlSessionTemplate之后，我们不再需要通过SqlSessionFactory.openSession()方法来创建SqlSession实例；使用完成之后，也不要调用SqlSession.close()方法进行关闭。另外，对于事务，SqlSessionTemplate 将会保证使用的 SqlSession 是和当前 Spring 的事务相关的。

通过构造器方式注入

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>

3.增加Mapper接口的实现类

方式一：自己写的Mapper实现类

私有化sqlSessionTemplate

@Component("userImp")
public class UserMapperImp implements UserMapper{
    //sqlSession不用我们自己创建了，Spring来管理
    @Autowired
    private SqlSessionTemplate sqlSessionTemplate;
    public UserMapper userMapper() {
        return sqlSessionTemplate.getMapper(UserMapper.class);
    }


    @Override
    public int add(User user) {
        return userMapper().add(user);
    }

    @Override
    public int delete(int id) {
        return userMapper().delete(id);
    }

    @Override
    public List<User> selectAll() {
        return userMapper().selectAll();
    }
}

方式二：SqlSessionDaoSupport

编写一个Dao类继承SqlSessionDaoSupport，调用其getSqlSession()方法来返回 SqlSessionTemplate。(与我们自己实现的实现类本质是一样的，只不过这个更方便一些)

public class UserMapperImp2 extends SqlSessionDaoSupport implements UserMapper {
    @Override
    public int add(User user) {
        return getSqlSession().getMapper(UserMapper.class).add(user);
    }

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

    @Override
    public List<User> selectAll() {
        return getSqlSession().getMapper(UserMapper.class).selectAll();
    }
}

我们要传给 SqlSessionDaoSupport 一个 sqlSessionFactory 或者传入一个sqlSessionTemplate，如果两者都传入了，会忽略掉sqlSessionFactory

    <bean id="userImp2" class="com.yang.mapper.UserMapperImp2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
    </bean>
    
    或

    <bean id="userImp2" class="com.yang.mapper.UserMapperImp2">
        <property name="sqlSessionTemplate" ref="sqlSession"/>
    </bean>

声明式事务的实现

Spring支持编程式事务管理和声明式的事务管理。

首先我们先改一下UserMapperImp2,让其有事务要求

public class UserMapperImp2 extends SqlSessionDaoSupport implements UserMapper {
    @Override
    public int add(User user) {
        return getSqlSession().getMapper(UserMapper.class).add(user);
    }

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

    @Override
    public List<User> selectAll() {
        add(new User(7,"小黑","1234"));
        delete(7);
        return getSqlSession().getMapper(UserMapper.class).selectAll();
    }
}

UserMapper.xml如下

我们故意把delete的sql语句写错了

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yang.mapper.UserMapper">
    <select id="selectAll" resultType="user">
        select * from user
    </select>
    <insert id="add" parameterType="user">
        insert into user values (#{id},#{name},#{pwd})
    </insert>
    <delete id="delete" parameterType="int">
        deletes from user where id = #{id}
    </delete>
</mapper>

现在我们运行selectAll，发现add方法执行成功，后面才报错，这不是我们想要的。

我们想要add和delete一起完成或者一起不完成。使用事务来实现。

导包

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

        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.aopalliance/com.springsource.org.aopalliance -->
        <dependency>
            <groupId>org.aopalliance</groupId>
            <artifactId>com.springsource.org.aopalliance</artifactId>
            <version>1.0.0</version>
        </dependency>

使用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"

获得事务管理器

    <bean id="transactionManger" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

配置好事务管理器后我们需要去配置事务的通知

<!--配置事务通知-->
<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事务传播特性：

事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。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:config>
        <aop:pointcut id="pointcut" expression="execution(* com.yang.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
    </aop:config>

不哦罗密经

关注

16
点赞
踩
28

收藏

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

切面(类) -> 切点pointcut(方法) -> 切面里的每一个通知是在切点得哪个地方执行1.写一个我们自己的切入类System.out.println(name+"方法执行前");System.out.println("方法执行后");2.去spring中配置。
复制链接

扫一扫