Spring详解

最新推荐文章于 2024-02-18 14:57:47 发布

来自湖南文理

最新推荐文章于 2024-02-18 14:57:47 发布

阅读量253

点赞数

分类专栏： Spring 文章标签： Spring

本文链接：https://blog.csdn.net/qq_38190823/article/details/117477890

版权

Spring 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

1 Spring概念
2 IoC容器
3 AOP
- 1.AOP底层使用动态代理
4 JdbcTemplate
- 1.xml文件配置
5 事务管理
5 注解开发源码分析
- 1.@EnableAspectJAutoProxy

1 Spring概念

1.概念

1、Spring是轻量级的开源的JavaEE框架。
2、Spring可以解决企业开发的复杂性。
3、spring两个核心：
IoC（控制反转）：把创建对象的过程交给Spring管理，不需要用new创建对象。
AOP（面向切面）：在不修改源代码的情况下进行功能的增强。

2.特点

1、方便解耦（IoC），简化开发（IoC）
2、对AOP的支持，不改变源代码可以增强功能
3、支持Junit方便程序测试
4、方便和其他框架整合
5、降低JavaEE的使用难度，比如JDBC、JavaMail、远程调用
6、方便进行事务操作
7、Java源码学习规范

3.创建Spring工程

1.要导入的jar包介绍

1、Core Container核心部分是必须要的jar包
2、commons-logging

在这里插入图片描述

2.需要引入的依赖

在这里插入图片描述

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.7</version>
        </dependency>
        <!-- 4.Spring test依赖：方便做单元测试和集成测试 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.7</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

3.配置文件bean.xml

创建xml格式的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">

    <!--配置User对象创建-->
    <bean id="user" class="com.ll.spring.User"></bean>
</beans>

4.单元测试

    @Test
    public void testAdd(){
        // 1.加载Spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
        // 2.获取配置创建的对象，user就是通过Spring创建的对象
        User user = context.getBean("user", User.class);
        // 3.调用方法
        user.add();
    }

5.项目结构

在这里插入图片描述

2 IoC容器

1.IoC基本概念

1、控制反转，把我们对象的创建还有对象直接调用的过程，交给Spring进行管理。
2、使用IoC是为了解耦

2.IoC底层原理

1、xml配置文件，配置需要创建的对象

<bean id="user" class="com.ll.spring.User"></bean>

2、有service和dao类，再创建一个工厂类
有关工厂模式的介绍

3、反射得到类的字节码文件，通过反射创建对象

public class UserFactory {
    public static UserDao userDao(){
        // 1、通过xml得到class="com.ll.spring.User"
        String classValue=class属性值;
        // 2、通过反射创建对象
        Class clazz = Class.forName(classValue);
        // 3、创建对象，反射无参的构造器，需要构造器可见；
        return (UserDao)clazz.newInstance();
    }
}

3.IoC接口（BeanFactory）

IoC的思想基于IoC的容器完成，IoC容器的底层就是对象工厂。

1.Spring提供IoC容器实现的两种方式

1.BeanFactory

IoC容器基本实现，是Spring内部使用的接口，不提供给开发人员使用
加载配置文件bean.xml的时候不会创建对象，在使用对象的时候才会创建对象

BeanFactory context=new ClassPathXmlApplicationContext("bean.xml");

2.ApplicationContext

BeanFactory接口的子接口，提供了更多更强大的功能，一般由开发人员使用。
在加载配置文件的时候，就会把对象创建
比较常用的是这一种方式，我们会把耗时耗资源的操作在项目启动的时候进行处理，在启动过程中就去创建对象。服务器启动就去执行代码，加载配置文件，创建对象的过程都在服务器启动的时候完成，把耗时耗资源的过程都交给服务器。

ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");

4.IoC操作Bean原理

1.什么是Bean管理

1.Spring创建对象
2.Spring属性注入
bean类的private String name;
get()和set()方法

2.Bean管理操作的两种方式

1.基于xml

1.Spring创建对象

1、在Spring配置文件中，实验bean标签，标签里面添加对象属性，皆可以实现对象创建。
2、常用属性
id：对象的唯一标识
class：类的全路径（包类路径）
3、创建对象的时候，默认也是执行无参的构造方法。（如果类里面含有参构造方法，必须显示声明无参构造方法）

2.Spring属性注入

DI（依赖注入）：是IoC中一种具体实现，就是注入属性。

private String name;将name中设置值

1.使用set方法注入

    <bean id="user" class="com.ll.spring.User">
        <property name="name" value="张三"></property>
    </bean>

2.有参构造注入

    <bean id="user" class="com.ll.spring.User">
        <constructor-arg name="name" value="张三"></constructor-arg>
        <!--<constructor-arg index="0" value="张三"></constructor-arg>-->
    </bean>

3.Springxml自动装配

在实际中xml自动装配用得少，注解自动装配用的多

手动装配：<property name=“name” value=“张三”></property>
根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入。

自动装配的两种方式：
1、属性名称装配autowire=“byName”，Bean的id要和类属性名一样
2、属性类型装配autowire=“byType”，不能有两个相同的Bean id

4.外部属性文件

1.直接配置数据库连接池

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://127.0.0.1/db_student?serverTimezone=UTC"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>

2.外部属性文件配置

//   jdbc.properties
prop.driverClassName=com.mysql.cj.jdbc.Driver
prop.url=jdbc:mysql://127.0.0.1/db_student?serverTimezone=UTC
prop.username=root
prop.password=123456

<?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">

    <!--在Spring配置文件中实验标签引入外部配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverClassName}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.username}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>
</beans>

2.基于注解

1.Spring创建对象

1.引入aop的依赖

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

2.开启注解扫描

1、xml开启
base-package：扫描包中所有类

<context:component-scan base-package="com.ll.dao"></context:component-scan>

    <!--扫描-->
    <context:component-scan base-package="com.ll" use-default-filters="false">
        <context:include-filter type="annotation" expression="com.ll.service"/>
    </context:component-scan>
    <!--不扫描-->
    <context:component-scan base-package="com.ll">
        <context:exclude-filter type="annotation" expression="com.ll.dao"/>
    </context:component-scan>

2、注解开启

@Configuration  // 作为配置类，代替xml文件
@ComponentScan(basePackages = {"com.ll"})
public class SpringConfig {
    
}

    @Test
    public void test2() {
        ApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
        DruidDataSource dataSource = context.getBean("dataSource", DruidDataSource.class);
        System.out.println(dataSource.getDriverClassName());
    }

3.创建类，引入注解

@Component
@Service
@Controller
@Repository

2.Spring属性注入

1.@Autowired根据属性类型自动装配

2.@Qualifier根据属性名称自动装配

@Qualifier要和@Autowired一起使用
@Autowired
@Qualifier(value = “userDao”)

3.@Resource可以根据属性类型、名称自动装配

@Resource根据属性类型注入
@Resource(name = “userDao”)根据属性名称注入

3.@Value注入普通类型

@Value(value = “abc”) 注入String
priviate String aaa;

3.FactoryBean

Spring有两种类型的Bean

一种是普通Bean：在配置文件中定义成什么类型就返回什么类型。
还有一种是FactoryBean：FactoryBean返回的类型可以是跟在配置文件中定义的不一样的。
1、创建类，这个类作为工厂Bean，实现FactoryBean。
2、实现接口里面的方法，在实现的方法中定义返回的Bean类型。

public class MyBean implements FactoryBean<User> {
    // 定义返回Bean
    public User getObject() throws Exception {
        User user = new User();
        user.setName("张三");
        return user;
    }

    // 返回类型
    public Class<?> getObjectType() {
        return null;
    }

    // 单例
    public boolean isSingleton() {
        return false;
    }
}

<!--bean.xml-->
<bean id="bean" class="com.ll.factory.MyBean"></bean>

    @Test
    public void test1(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
        // 注意这里是User.class而不是MyBean.class
        User bean = context.getBean("bean", User.class);
        System.out.println(bean);
    }

4.Bean的作用域

1、在Spring里面，可以设置创建的Bean实例是单实例还是多实例的。
2、默认创建的是单实例对象。
3、设置Bean是单实例还是多实例。

scope设置：
singleton表示是单实例，singleton在加载Spring配置文件的时候就会创建单实例对象。ApplicationContext context=new ClassPathXmlApplicationContext(“bean.xml”);
prototype表示是多实例，是在调用getBean方法时才创建多实例对象。User user = context.getBean(“user”, User.class);
request、session

5.Bean的生命周期

生命周期：从对象创建到对象销毁的过程。

1.基本方法

1、通过构造器创建Bean实例（无参构造）
2、为bean的属性设置值和对其他Bean引用（调用set方法）
3、调用Bean的初始化的方法（需要进行配置）
4、Bean可以使用了（对象获取到了）
5、当容器关闭的时候，调用Bean的销毁方法（需要进行配置销毁的方法）

    <bean id="user" class="com.ll.spring.User" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="张三"></property>
    </bean>

public class User {
    private String name;

    public User() {
        System.out.println("1、通过构造器创建Bean实例（无参构造）");
    }

    public void setName(String name) {
        System.out.println("2、为bean的属性设置值和对其他Bean引用（调用set方法）");
        this.name = name;
    }

    // 创建执行的初始化方法
    public void initMethod(){
        System.out.println("3、调用Bean的初始化的方法（需要进行配置）");
    }

    public void destroyMethod(){
        System.out.println("5、当容器关闭的时候，调用Bean的销毁方法（需要进行配置销毁的方法）");
    }
}

2.Bean的后置处理实现BeanPostProcessor接口

1、通过构造器创建Bean实例（无参构造）
2、为bean的属性设置值和对其他Bean引用（调用set方法）
把Bean实例传递Bean后置处理器的方法
3、调用Bean的初始化的方法（需要进行配置）
把Bean实例传递Bean后置处理器的方法
4、Bean可以使用了（对象获取到了）
5、当容器关闭的时候，调用Bean的销毁方法（需要进行配置销毁的方法）

<bean id="myBeanPost" class="com.ll.spring.MyBeanPost"></bean>

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化后执行的方法");
        return bean;
    }
}

3 AOP

AOP面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

不通过源代码的方式添加新的功能

1.AOP底层使用动态代理

1.有接口的情况，使用JDK动态代理

创建接口实现类代理对象，增强类的方法
在这里插入图片描述

1.newProxyInstance方法

使用Proxy类（java.lang.reflect.Proxy）创建代理对象。

// ClassLoader类加载器
// interfaces增强方法所在的类，这个类实现的接口，支持多个接口
// 实现这个接口InvocationHandler，创建代理对象，写增强的方法
public static Object newProxyInstance(ClassLoader loader,
        Class<?>[] interfaces,
        InvocationHandler h)

2.底层原理

public class JDKProxy {
    public static void main(String[] args) {
        ClassLoader loader=JDKProxy.class.getClassLoader();
        Class[] interfaces={UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        InvocationHandler h=new UserDaoProxy(userDao);
        UserDao dao = (UserDao) Proxy.newProxyInstance(loader, interfaces, h);
        int add = dao.add(1, 3);
//        System.out.println("方法执行的结果是："+add);
    }
}

// 创建代理对象
class UserDaoProxy implements InvocationHandler{
    private Object obj;
    // 把创建的是谁的代理对象，把谁传递过来
    // 有参构造传递
    public UserDaoProxy(Object obj){
        this.obj=obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法之前
        System.out.println("方法之前执行："+method.getName()+":传递的参数："+ Arrays.toString(args));
        // 被增强的方法执行
        Object invoke = method.invoke(obj, args);
        // 方法之后
        System.out.println("方法之后执行："+obj);
        return invoke;
    }
}

3.AOP术语

在这里插入图片描述

4.AOP操作（AspectJ）

Spring中一般都是基于AspectJ实现AOP操作
AspectJ：不是Spring的组成部分，独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作。

1.引入AOP和AspectJ依赖

<dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.8.9</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjtools -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjtools</artifactId>
      <version>1.8.9</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.7.4</version>
    </dependency>

2.切入点表达式

知道哪个类里面的哪个方法增强
语法结构：execution（[权限修饰符][返回类型][类全路径]方法名称）
execution(*com.ll.dao.UserDao.add(…))

1.AspectJ注解实现AOP（一般使用）

1.AspectJ注解实现流程

1、在Spring配置文件中，开启注解扫描
2、使用@Component注解将User和UserProxy对象放入IoC容器中
3、在增强的类Proxy上添加@Aspect注解
4、在Spring配置文件中开启生成代理对象

    <!--开启注解扫描-->
    <context:component-scan base-package="com.ll"/>
    <!--开启aspectj生成代理对象，将有@Aspect注解的类生成代理对象-->
    <aop:aspectj-autoproxy/>

完全使用注解开发：

@Configuration  // 作为配置类，代替xml文件
@ComponentScan(basePackages = {"com.ll"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class SpringConfig {

}

// 增强的类
@Component
@Aspect  //生成代理对象
public class UserProxy {
    // 前置通知
    @Before(value = "execution(* com.ll.spring.UserDao.add(..))")
    public void before(){
        System.out.println("前置通知before");
    }

    // 最终通知
    @After(value = "execution(* com.ll.spring.UserDao.add(..))")
    public void after(){
        System.out.println("最终通知after");
    }

    // 后置通知
    @AfterReturning(value = "execution(* com.ll.spring.UserDao.add(..))")
    public void afterReturning(){
        System.out.println("后置通知afterReturning");
    }

    // 异常通知
    @AfterThrowing(value = "execution(* com.ll.spring.UserDao.add(..))")
    public void afterThrowing(){
        System.out.println("异常通知afterThrowing");
    }

    // 环绕通知，在方法执行前后都执行
    @Around(value = "execution(* com.ll.spring.UserDao.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知之前around");
        // 执行方法
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知之后around");
    }
}

2.相同切入点抽取

    @Pointcut(value = "execution(* com.ll.spring.UserDao.add(..))")
    public void pointcut(){
        
    }
    
    // 前置通知
    @Before(value = "pointcut()")
    public void before(){
        System.out.println("前置通知before");
    }

3.多个增强类的优先级

@Order(0) //数字越小优先级越高

2.AspectJ xml实现AOP

    <!--创建对象-->
    <bean id="book" class="com.ll.spring.Book"/>
    <bean id="bookProxy" class="com.ll.spring.BookProxy"/>
    <!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.ll.spring.Book.buy(..))"/>
        <!--切面-->
        <aop:aspect ref="bookProxy">
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>

1.连接点

增删改查的四个方法叫连接点

2.切入点

实际被增强的方法，叫切入点

3.通知（增强）

1、实际增强逻辑的部分叫通知（实际增加的部分）
2、通知的五种类型

前置通知
后置通知
环绕通知
异常通知
最终通知

3、执行顺序
无异常

环绕通知之前around
前置通知before
UserDao：add
后置通知afterReturning
最终通知after
环绕通知之后around

有异常

环绕通知之前around
前置通知before
异常通知afterThrowing
最终通知after

4.切面

是动作，把通知应用到切入点的过程。

2.没有接口的情况，使用CGLIB动态代理

创建子类的代理对象，增强类的方法
在这里插入图片描述

4 JdbcTemplate

1.xml文件配置

1.引入依赖
2.在spring的配置文件中配置数据库连接池
3.配置JdbcTemplate对象

    <!--开启注解扫描-->
    <context:component-scan base-package="com.ll"/>

    <!--在Spring配置文件中实验标签引入外部配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverClassName}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.username}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>

    <!--配置JdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入DataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

5 事务管理

事务管理加到service层上

1.Spring事务管理API

提供了PlatformTransactionManager接口，代表事务管理器，这个接口针对不同的框架提供了不同的实现类。
在这里插入图片描述

2.Spring事务管理两种形式

1.Spring编程式事务管理

    public void account(int id1,int id2){
        try {
            // 1、开启事务操作

            // 2、进行业务操作
            bankDao.delete(id2);
            bankDao.add(id2);
            // 3、提交事务
        }catch (Exception exception){
            // 4、出现异常，回滚

        }
    }

2.Spring声明式事务管理（推荐）

1.注解声明式事务管理（推荐）

1.xml配置

    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--开启数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--开启事务注解-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

2.事务管理@Transactional注解

可以添加在类或方法上面

@Service
@Transactional //可以添加在类或方法上面
public class BankService {
    @Autowired
    BankDao bankDao;

    public void account(int id1,int id2){
        bankDao.delete(id2);
        int i=1/0;
        bankDao.add(id2);
    }
}

1.propagation：事务的传播行为

默认为REQUIRED
事务的传播行为：多事务方法直接进行调用，这个过程中事务是如何进行管理的（例如：A方法和B方法，A去调用B该怎么调用。AB均有事务，A有B无，A无B有）
事务方法：对数据库表诗句进行变化的操作（添加、删除、更新）
REQUIRED和REQUIRED_NEW比较重要
在这里插入图片描述

2.isolation：事务的隔离级别

隔离性：多事务操作之间不会产生影响
脏读：一个未提交事务A读取到另一个未提交事务B的数据，B回滚了，A读的就是错的数据
不可重复读：一个未提交事务A读取到另一个已提交事务B修改的数据
幻读：一个未提交事务A读取到另一个已提交事务B添加的数据

通过设置事务的隔离级别，解决读的问题。MySQL默认设置可重复读。
在这里插入图片描述

3.timeout：超时时间

事务要在一定时间内进行提交，如果不提交，则回滚。
默认值是-1，不超时。

4.readOnly：是否只读

readOnly默认false

5.rollbackFor：回滚

设置哪些异常进行回滚

6.noRollbackFor：不回滚

设置哪些异常进行不回滚

2.xml声明式事务管理

    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--开启数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--配置通知-->
    <tx:advice id="advice">
        <!--配置事务参数-->
        <tx:attributes>
            <!--指定哪种规则的方法上添加事务-->
            <tx:method name="account" propagation="REQUIRED"/>
            <!--所有account开头的方法都天啊及事务-->
            <!--<tx:method name="account*"/>-->
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="p" expression="execution(* com.ll.service.BankService.*(..))"/>
        <!--配置切面-->
        <aop:advisor advice-ref="advice" pointcut-ref="p"/>
    </aop:config>

3.完全注解开发

@Configuration
@ComponentScan(value = "com.ll")
@EnableTransactionManagement  // 开启事务
public class MyConfig {
    // 创建数据库连接池
    @Bean
    public DruidDataSource druidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&tinyInt1isBit=false");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("123456");
        return druidDataSource;
    }

    // 创建数据库连接池
    @Bean
    public JdbcTemplate jdbcTemplate(DruidDataSource druidDataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(druidDataSource);
        return jdbcTemplate;
    }

    // 创建事务管理器
    @Bean
    public DataSourceTransactionManager dataSourceTransactionManager(DruidDataSource druidDataSource){
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(druidDataSource);
        return dataSourceTransactionManager;
    }
}

5 注解开发源码分析

1.@EnableAspectJAutoProxy

来自湖南文理

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Spring详解

文章目录1 Spring概念1.概念2.特点3.创建Spring工程1.要导入的jar包介绍2.需要引入的依赖3.配置文件bean.xml4.单元测试5.项目结构2 IoC容器1.IoC基本概念2.IoC底层原理3.IoC接口（BeanFactory）1.Spring提供IoC容器实现的两种方式1.BeanFactory2.ApplicationContext4.IoC操作Bean原理1.什么是Bean管理2.Bean管理操作的两种方式1.基于xml1.Spring创建对象2.Spring属性注入2.基于注
复制链接

扫一扫

专栏目录