Spring框架知识要点总结

最新推荐文章于 2023-04-14 15:07:47 发布
最新推荐文章于 2023-04-14 15:07:47 发布
阅读量452 收藏 2
点赞数 1
分类专栏： 开发框架 文章标签： java spring 程序人生 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43731419/article/details/105206536
版权

spring框架

1、JavaEE开发的三层架构：

①web层：springmvc框架

②dao层：mybatis框架

③service

spring框架不属于任何一层，但是存在于每一层。

2、spring是什么？

Spring是分层的JavaEE/SE应用，全栈轻量级开源框架，以IOC和AOP为内核。

提供了展现层springmvc和持久层spring JDBCTemplate以及业务层事务管理等重多的企业级应用技术，还整合了开源世界重多注明的第三方框架和类库，逐渐成为使用最多的JavaEE企业级开源框架。

3、spring的优势

①方便解耦，简化开发：通过spring提供的IOC容器，可以将对象间的依赖关系交由spring进行控制，避免硬编码锁造成的过度耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

②AOP编程的支持：通过spring的AOP功能，方便进行面向切面编程，许多不容易用传统OOP实现的功能可以通过AOP轻松实现。

③声明式事务的支持：可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务管理，提高开发效率和质量。

④方便程序的测试：可以使用非容器依赖的编程方式进行几乎所有的测试工作，测试工作不再是昂贵的操作，而是随手可做的事情。

⑤方便继承各种优秀的框架：spring对各种优秀的框架（Struts、hibernate、hessian、quartz等）的支持。

⑥降低javaEE API的使用难度：spring对javaEE API（如JDBC、JavaMail、远程调用等）进行了薄薄的封装，使这些API的使用难度大为降低。

⑦Java的源码设计精妙、结构清晰、匠心独用、处处体现着大师对Java设计模式的灵活运用以及对Java技术的高深造诣。它的源码无疑是Java技术的最佳实现的范例。

4、spring程序开发步骤：

①导入spring开发的基本的坐标

②编写Dao接口和实现类（创建bean）

③创建spring核心配置文件

④在spring配置文件中配置UserDaoImpl

⑤使用spring的API获得Bean实例

5、spring的配置文件

1、bean标签的基本配置：用于配置对象交由spring来创建；默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

基本属性：

  • id：bean实例在spring容器中的唯一标识（不允许重复）
  • class：bean的全限定名称

2、bean标签的范围配置：

scope：指对象的作用范围取值如下：

  • singleton：默认值，单例的

    • 当scope的属性为singleton时：

      • bean的实例化个数：1个
      • bean的实例化时机：当spring核心文件被加载时，实例化配置的bean实例。

    bean的生命周期：

    • 对象创建：当应用加载，创建容器时，对象就被创建了

    • 对象运行：只要容器在，对象一直活着

    • 对象销毁：当应用卸载，销毁容器时，对象就被销毁了。

  • prototype：多例的

    • 当scope的属性为prototype时：

      • bean的实例化个数：多个
      • bean的实例化时机：当调用getBean()方法时实例化bean

      bean的生命周期：

      • 对象的创建：当使用对象时，创建新的对象实例
      • 对象的运行：只要对象在使用中，就一直活着。
      • 对象销毁：当对象长时间不用时，被Java的垃圾回收器回收了。

3、bean的生命周期配置：

  • init-method：指定类中的初始化方法名称
  • destroy-method：指定类中销毁方法名称

4、bean的实例化三种方式：

  • 无参构造方法实例化（重点）
  • 工厂静态方法实例化（了解）
  • 工厂实例方法实例化（了解）

5、bean的依赖注入概念：它是spring框架核心IOC的具体实现。

  • 编写程序时，通过控制反转，把对象的创建权交给spring，但是代码中不可能出现没有依赖的情况。IOC解耦只是降低它们的依赖关系，但是不会消除。
  • 那这种业务层和持久层的依赖关系，在使用spring之后，就让spring来维护了。简单来说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

6、bean的依赖注入方式：

  • 构造方法注入：配置文件添加 constructor-arg 子标签

    • <bean id="userService" class="com.itheima.service.Impl.UserServiceImpl">
	<constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

  • set方法注入：

    • P命名空间注入本质也是set方法注入，但是比起上述的set方法注入更加方便，主要体现在配置文件中，如下：首先，需要引入P命名空间,然后再修改注入方式：

      • xmlns:p="http://www.springframework.org/schema/p"

      • <bean id ="userService" class="com.itheima.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

7、bean的依赖注入的数据类型：除了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入。

  • 注入数据的三种数据类型

    • 引用数据类型

    • 普通数据类型

      • <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
        <property name="username" value="张三"></property>
        <property name="age" value="88"></property>
</bean>

    • 集合数据类型

      • <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
        <property name="strList">
            <list>
                <value>aaa</value>
            </list>
        </property>
        <property name="userMap">
            <map>
                <entry key="u1" value-ref="user1"></entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="p1">p</prop>
            </props>
        </property>
    </bean>

8、引入其他配置文件（分模块开发）

  • 实际开发中，spring的配置内容非常多，就是导致spring配置很繁杂且体积很大，所以可以将部分配置拆解到其他配置文件中，而在spring主配置文件中通过import标签进行加载：

    <import resource="applicationContext-xxx.xml"/>

9、spring的重点配置：

<bean>标签
    id属性：在容器中bean实例的唯一标识，不允许重复
	class属性：要实例化的bean的全限定名
    scope属性：bean的作用范围，常用的是singletion（默认）和prototype
    <property>标签：属性注入
        name属性：属性名称
        value属性：注入的普通属性值
        ref属性：注入的对象引用值
        <list>标签
        <map>标签
        <properties>标签
        <constructor-arg>标签
    </property>
</bean>
<import>标签：导入其他的spring配置文件

6、spring相关的API

1、ApplicationContext的实现类

  • ClassPathXmlApplicationContext

    它是从类的根路径下加载配置文件（推荐使用）

  • FileSystemXmlApplicationContext

    它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

  • AnnotationConfigApplicationContext

    当使用注解配置容器对象时，需要使用此类来创建spring容器。它用来读取注解。

2、spring的重点API

  • 创建应用上下文对象的三种方式和getBean的两种使用方式使用：
ApplicationContext app = new ClasspathXmlApplicationContext("xml文件");
app.getBean("id");
app.getBean(class);

7、spring配置数据源

1、数据源（连接池）的作用
  • 数据源(连接池)是为提高程序性能而出现的
  • 事先实例化数据源，初始化部分连接资源
  • 使用链接资源时，从数据源中获取
  • 使用完毕之后将链接资源归还给数据源

常见的数据源(连接池)：DBCP、C3P0、BoneCP、Druid等

2、数据源的开发步骤

  • 导入数据源坐标和数据库驱动坐标

  • 创建数据源对象

  • 设置数据源的基本连接参数（驱动、数据库地址、用户名、用户密码）

  • 使用数据源获取连接资源和归还连接资源

    • 手动创建c3p0数据源

      //创建数据源对象
ComboPooledDataSource dataSource = new ComboPooledDataSource();
//设置数据源的基本连接参数
dataSource.setDriverClass("com.mysql.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
dataSource.setUser("root");
dataSource.setPassword("root");
//使用数据源对象获取链接资源对象
Connection connection = dataSource.getConnection();

    • 手动创建druid数据源

      //获取数据源对象
DruidDataSource dataSource = new DruidDataSource();
//设置基本的连接参数
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/test");
dataSource.setUsername("root");
dataSource.setPassword("root");
//使用数据源对象获取链接资源对象
DruidPooledConnection connection = dataSource.getConnection();

    • 提取jdbc.properties配置文件

      jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

    • 读取jdbc.properties配置文件创建连接池

      //加载类路径下的jdbc.properties
ResourceBundle rb = ResourceBundle.getBundle("jdbc");
String driver = rb.getString("jdbc.driver");
String url = rb.getString("jdbc.url");
String username = rb.getString("jdbc.username");
String password = rb.getString("jdbc.password");
//创建数据源对象
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setDriverClass(driver);
dataSource.setJdbcUrl(url);
dataSource.setUser(username);
dataSource.setPassword(password);
//使用数据源获取链接资源
Connection connection = dataSource.getConnection();
System.out.println(connection);
3、spring配置数据源

可以将dataSource的创建权交给spring容器去完成

dataSource有无参构造，而spring默认就是通过无参构造方法实例化对象的

dataSource要想使用，需要通过set方法设置数据库链接信息，而spring可以通过set方法进行字符串注入

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
    <property name="user" value="root"/>
    <property name="password" value="root"/>
</bean>

测试从容器当中获取数据源

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
DataSource dataSource = app.getBean(DataSource.class);
Connection connection = dataSource.getConnection();
System.out.println(connection);
connection.close();
4、抽取jdbc配置文件

  • applicationContext加载jdbc.properties配置文件获得连接信息。

    • 首先，需要引入context命名空间和约束路径

    命名空间：

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

    约束路径：

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

  • 知识要点：

    • spring容器加载properties配置文件
    <context:property-placeholder location="xx.properties"/>
<property name="" value="${key}"/>

8、spring注解开发

1、spring原始注解

  • spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml文件可以简化配置，提高开发效率。

  • spring原始注解主要是替代的配置

    注解说明
    @Component使用在类上，用于实例化bean
    @Controller使用在web层的类上，用于实例化bean
    @Service使用在service层的类上，用于实例化bean
    @repository使用在dao层的类上，用于数理化bean
    @Autowired使用在字段上，用于根据类型依赖注入
    @Qualifier结合@Autowired一起使用，用于根据名称进行依赖注入
    @Resource相当于@Autowired＋@Qualifier，按照名称进行依赖注入
    @Value注入普通属性
    @Scope标注bean的作用范围
    @PostConstruct使用在方法上，标注该方法是bean的初始化方法
    @PreDestory使用在方法上，标注该方法是在bean的销毁方法

    注意：使用注解开发时，需要在applicationContext.xml配置文件中配置组件扫描，作用是指定哪个包及其子包下的bean需要进行扫描以便识别使用注解配置的类、字段和方法。

    <!--配置组件扫描，扫描范围itheima包及其子包下的bean-->
<context:component-scan base-package="com.itheima"/>
2、spring新注解

  • 使用上面的注解还能全部代替xml配置文件，还需要使用注解代替的配置如下：

    • 非自定义的bean的配置：

    • 加载properties文件的配置：context:property-placeolder

    • 组件扫描的配置：context:component-scan

    • 引入其他文件：

      注解说明
      @Configuration用于指定当前类是一个spring的核心配置类，当创建容器时会从该类上加载注解
      @ComponentScan用于指定spring在初始化容器时要扫描的包。作用和在spring的xml配置文件中的<context:component-scan base-package=“com.itheima”/>一样
      @Bean使用在方法上，标注该方法返回值存储到spring容器中
      @PropertySource用于加载.properties文件中的配置
      @Import用于导入其他配置类

9、Spring整合Junit

1、原始Junit测试spring的问题

  • 在测试类中，每个测试方法都可以有以下两行代码：

    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
IAccountService as = ac.getBean("accountService",IAccountService.class);

    这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉。

  • 上述问题解决思路

    让SpringJunit负责创建spring容器，但是需要将配置文件的名称告诉它

    将需要进行测试的bean直接在测试类中进行注入

  • spring集成Junit步骤：

    ①导入spring集成Junit的坐标

    ②使用@Runwith注解替换原来的运行器

    ③使用@ContextConfiguration指定配置文件或配置类

    ④使用@Autowired注入需要测试的对象

    ⑤创建测试方法进行测试

10、spring的AOP

1、什么是AOP？

AOP为Aspect Oriented Programming的缩写，意思是面向切面编程，是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

AOP是OOP的延续，是软件开发中的一个热点，也是spring框架中的一个重要内容，是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2、AOP的作用和优势
  • 作用：在程序运行期间，在不修改源码的情况下对方法进行功能性增强。
  • 优势：减少重复代码，提高开发效率，并且便于维护
3、AOP的底层实现
  • 实际上，AOP的底层是通过spring提供的动态代理技术实现的。在运行期间，spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，再去调用目标对象的方法，从而完成功能的增强。
4、AOP的动态代理技术

常用的动态代理技术：

  • JDK代理：基于接口的动态代理技术
  • cglib代理：基于父类的动态代理技术
5、JDK的动态代理

①目标接口

public interface TargetInterface {
    public void method();
}

②目标类

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

③动态代理代码

//创建目标对象
final Target target = new Target();
//增强对象
final Advice advice = new Advice();
//返回值就是动态生成的代理对象
TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
	//目标对象类加载器
	target.getClass().getClassLoader(),
	//目标对象相同的接口字节码对象数组
	target.getClass().getInterfaces(),
	new InvocationHandler() {
	//调用代理对象的任何方法，实质执行的都是invoke方法
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		advice.before();//前置增强
		Object invoke = method.invoke(target, args);//执行目标法
		advice.afterReturning();//后置增强
		return invoke;
	}
});

④调用代理对象的方法测试

//调用代理对象的方法
proxy.save();
6、cglib的动态代理

①目标类

public class Target {
    public void method() {
        System.out.println("Target running....");
    }
}

②动态代理代码

Target target = new Target(); //创建目标对象
Enhancer enhancer = new Enhancer();   //创建增强器
enhancer.setSuperclass(Target.class); //设置父类
enhancer.setCallback(new MethodInterceptor() { //设置回调
    @Override
    public Object intercept(Object o, Method method, Object[] objects, 
    MethodProxy methodProxy) throws Throwable {
        System.out.println("前置代码增强....");
        Object invoke = method.invoke(target, objects);
        System.out.println("后置代码增强....");
        return invoke;
    }
});
Target proxy = (Target) enhancer.create(); //创建代理对象

③调用代理对象的测试方法

//测试,当调用接口的任何方法时，代理对象的代码都无序修改
proxy.method();
7、AOP的相关概念

1、spring的AOP实现底层就是随上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

2、AOP的相关术语

  • Target（目标对象）：代理的目标对象，要被增强的对象
  • Proxy（代理）：一个类被AOP织入增强后，就产生了一个结果代理类
  • Joinpoint（连接点）：所谓的连接点是指那些被拦截到的点。在spring中，这些点指的是方法，因为spring只支持方法类型的连接点。（可以被增强的方法叫做连接点）
  • Pointcut（切入点）：所谓的切入点是指我们要对哪些Joinpoint进行拦截的定义（被增强的连接点叫做切入点）
  • Advice（通知/增强）：所谓的通知是指拦截到joinpoint之后所要做的事情就是通知/增强
  • Aspect（切面）：是切入点和通知的结合
  • Weaving（织入）：就是将切点和增强结合的过程
8、AOP开发的明确事项

1、需要编写的内容：

  • 编写核心业务代码（目标类的目标方法）
  • 编写切面类，切面类中有通知（增强功能方法）
  • 在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合

2、AOP技术实现的内容

  • spring框架监控切入点方法的执行。一旦监控到切入点的执行，使用代理机制，动态的创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

3、AOP底层使用哪种代理方式？

  • 在spring中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。
9、知识要点
  • AOP：面向切面编程
  • AOP底层实现：基于JDK的动态代理和基于cglib的动态代理
  • AOP的重点概念：
    • pointcut（切入点）：被增强的方法
    • Advice（通知/增强）：封装增强业务逻辑的方法
    • Aspect（切面）：切点+通知
    • Weaving（织入）：将切点与通知结合的过程
  • 开发明确事项：
    • 谁是切点（切点表达式配置）
    • 谁是通知（切面类中的增强方法）
    • 将切点和通知进行织入配置

11、基于XML的AOP开发

1、快速入门

①导入AOP相关坐标

<!--导入spring的context坐标，context依赖aop-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>
<!-- aspectj的织入 -->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.13</version>
</dependency>

②创建目标类接口和目标类（内部有切点）

public interface TargetInterface {
    public void method();
}

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

③创建切面类（内部有增强方法）

public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

④将目标类和切面类的对象创建权交给spring

<!--配置目标类-->
<bean id="target" class="com.itheima.aop.Target"></bean>
<!--配置切面类-->
<bean id="myAspect" class="com.itheima.aop.MyAspect"></bean>

⑤在applicationContext.xml中配置织入关系（告诉spring框架，哪些方法(切点)需要进行哪些增强）

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

在applicationContext.xml中配置织入关系：

<aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
        <!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
        <aop:before method="before" pointcut="execution(public void com.itheima.aop.Target.method())"></aop:before>
    </aop:aspect>
</aop:config>

⑥测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}
2、XML配置AOP详解

①切点表达式：

表达语法：

excution([修饰符] 返回值类型 包名.类名.方法名(参数))
  • 访问修饰符可以省略
  • 返回值类型、包名、类名、方法名可以使用星号*代表任意
  • 包名 与类名之间一个点.代表当前包下的类，两个点…表示当前包及其子包下的类
  • 参数列表可以使用两个点…表示任意个数，任意类型的参数列表

②通知的类型

通知的配置语法：

<aop:通知类型 method=“切面类中的方法名” pointcut=“切点表达式”></aop:通知类型>

通知类型：

名称标签说明
前置通知<aop:before>用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知<aop:after-returning>用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知<aop:around>用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知<aop:throwing>用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知<aop:after>用于配置最终通知。无论赠强的方法执行是否有异常都会执行

③切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用pointcut-ref属性代替pointcut属性来引用抽取后的切点表达式。

<aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
        <aop:pointcut id="myPointcut" expression="execution(* com.itheima.aop.*.*(..))"/>
        <aop:before method="before" pointcut-ref="myPointcut"></aop:before>
    </aop:aspect>
</aop:config>
3、知识要点

  • AOP的织入配置

    <!--配置织入：告诉spring，哪些方法需要进行哪些增强-->
<aop:config>
	<!--声明切面-->
    <aop:aspect ref="切面类">
		<!--切面：切点+通知（增强）-->
 		<aop:around method="通知方法名称" pointcut="切点表达式></aop:around>
 	</aop:aspect>
</aop:config>

  • 通知的类型：前置通知、后置通知、环绕通知、异常抛出通知、最终通知

  • 切点表达式的写法：

    execution([修饰符] 返回值类型 包名.类名.方法名(参数))

12、基于注解的AOP开发

1、快速入门
  • 基于注解的AOP开发步骤：
    • 创建目标接口和目标类（内部有切点）
    • 创建切面类（内部有增强方法）
    • 将目标类和切面类的对象的创建权交给spring
    • 在切面类中使用注解配置织入关系
    • 在配置文件中开启组件扫描和AOP的自动代理
    • 测试

①创建目标接口和目标类（内部有切点）

public interface TargetInterface {
    public void method();
}

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

②创建切面类（内部有增强方法）

public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

③将目标类和切面类的对象创建权交给spring

@Component("target")
public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}
@Component("myAspect")
public class MyAspect {
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

④在切面类中使用注解配置织入关系

@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("execution(* com.itheima.aop.*.*(..))")
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

⑤在配置文件中开启组件扫描和AOP的自动代理

<!--组件扫描-->
<context:component-scan base-package="com.itheima.aop"/>

<!--aop的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

⑥测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}
2、注解配置AOP详解

①注解通知的类型

通知的配置语法：@通知注解(“切点表达式”)

名称注解说明
前置通知@Before用于配置前置通知，指定增强的方法在切入点方法之前执行
后置通知@AfterReturning用于配置后置通知，指定增强的方法在切入点方法之后执行
环绕通知@Around用于配置管绕通知，指定增强的方法在切入点方法之前和之后都执行
异常抛出通知@AfterThrowing用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知@After用于配置最终通知，无论增强方式执行是否有异常都会执行

②切点表达式的抽取

同xml配置aop一样，我们可以将切点表达式抽取。抽取方式是在切面内定义方法，在该方法上使用@Pointcut注解定义切点表达式，然后在增强注解中进行引用，具体如下：

@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("MyAspect.myPoint()")
    public void before(){
        System.out.println("前置代码增强.....");
    }
    @Pointcut("execution(* com.itheima.aop.*.*(..))")
    public void myPoint(){}
}

③知识要点

  • 注解aop开发步骤
  • 通知注解类型

13、spring JdbcTemplate基本使用

1、JdbcTemplate概述
  • 它是spring框架中提供的一个对象，是对原始繁琐的JdbcAPI对象的简单封装，spring框架为我们提供了很多的操作模板类。例如：操作关系型数据库的JdbcTemplate和HibernateTemplate，操作nosql数据库的RedisTemplate，操作消息队列的JmsTemplate等等。
2、JdbcTemplate开发步骤

  • ①导入spring-jdbc和spring-tx坐标

    <!--导入spring的jdbc坐标-->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>5.0.5.RELEASE</version>
</dependency>
<!--导入spring的tx坐标-->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-tx</artifactId>
	<version>5.0.5.RELEASE</version>
</dependency>

  • ②创建数据库表和实体

  • ③创建JdbcTemplate对象

  • ④执行数据库操作

3、spring产生JdbcTemplate对象

我们可以将JdbcTemplate的创建权交给spring，将数据源Datasource的创建权也交给spring，在spring容器内部将数据源DataSoutce注入到JdbcTemplate模板对象中，配置如下：

    <!--数据源对象-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!--jdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
4、知识要点

①导入spring-jdbc和spring-tx坐标

②创建数据库表和实体

③创建JdbcTemplate对象

④执行数据库操作

  • 更新操作：
    • jdbcTemplate.update(sal,params)
  • 查询操作
    • jdbcTemplate.query(sql,mapper,params)
    • jdbcTemplate.queryForObject(sql,mapper,params)

14、spring的声明式事务控制

1、编程式事务控制相关对象

1.1PlatformTransactionManager（平台事务管理器）

  • PlatformTransactionManager接口是spring的事务管理器，它里面提供了我们常用的操作事务的方法。

    方法说明
    TransactionStatus getTransaction(TransactionDefination defination)获取事务的状态信息
    void commit(TransactionStatus status)提交事务
    void rollback(TransactionStatus ststus)回滚事务

    注意：
    PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类，例如：Dao 层技术是jdbc 或 mybatis 时：org.springframework.jdbc.datasource.DataSourceTransactionManager
    Dao 层技术是hibernate时：org.springframework.orm.hibernate5.HibernateTransactionManager

1.2TransactionDefinition（事务的定义对象）

  • TransactionDefinition是事务的定义信息对象，里面有如下方法：

    方法说明
    int getIsolationLevel()获得事务的隔离级别
    int getPropogationBehavior()获得事务的传播行为
    int getTimeout()获得超时时间
    boolean isReadOnly()是否只读

  • 事务的隔离级别：设置事务的隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读。

    • ISOLATION_DEFAULT
    • ISOLATION_READ_UNCOMMITTED（读未提交）
    • ISOLATION_READ_COMMITTED（读已提交）
    • ISOLATION_REPEATABLE_READ（可重复读 /MySQL数据库默认隔离级别）
    • ISOLATION_SERIALIZABLE（串行化）

  • 事务的传播行为

    • REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）
    • SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）
    • MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常
    • REQUERS_NEW：新建事务，如果当前在事务中，把当前事务挂起。
    • NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
    • NEVER：以非事务方式运行，如果当前存在事务，抛出异常
    • NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED 类似的操作
    • 超时时间：默认值是-1，没有超时限制。如果有，以秒为单位进行设置
    • 是否只读：建议查询时设置为只读

1.3TransactionStatus（事务的状态对象）

  • TransactionStatus接口提供的是事务具体的运行状态，方法介绍如下：

    方法说明
    boolean hsaSavepoint()是否储存回滚点
    boolean isCompleted事务是否完成
    boolean isNewTransaction是否是新事务
    boolean isRollbackOnly事务是否回滚

1.4知识要点：

编程式事务控制的三大对象

  • PlatformTransactionManager（平台事务管理器）
  • TransactionDefinition（事务的定义对象）
  • TransactionStatus（事务的状态对象）

15、基于XML的声明式事务控制

1、什么是声明式事务控制

  • spring的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明，就是指在配置文件中声明，用在spring配置文件中声明式的处理事务来代替代码式的处理事务。

  • 声明式事务处理的作用优点

    • 事务管理不侵入开发的组件。具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此。因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可。
    • 在不需要事务管理的时候，只要在设定文件上修改一下，即可移除事务管理服务，无需改变代码重新编译，这样维护起来极其方便。

    注意：spring声明式事务控制底层就是AOP。

2、声明式事务控制的实现

1、声明式事务控制明确事项：

  • 谁是切点？（就是业务方法）
  • 谁是通知？（事务控制）
  • 配置切面？

2、声明式事务控制的实现

①引入P命名空间

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

②配置事务增强

<!--平台事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"></property>
</bean>

<!--事务增强配置-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">				<tx:attributes>
		<tx:method name="*"/>
	</tx:attributes>
</tx:advice>

③配置事务的aop织入

<!--事务的aop增强-->
<aop:config>
	<aop:pointcut id="myPointcut" expression="execution(* com.itheima.service.impl.*.*(..))"/>
	<aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut">				</aop:advisor>
</aop:config>

④测试

3、切点方法的事务参数的配置

<!--通知 事务的增强
advisor:通知器  其实也就是一个切面 = 切入点 +　通知
        如果通知类(增强类)是Spring提供的,或者是实现了Spring的 XXXAdvice接口 都要使用		advisor去配置切面
aspect　:切面　　
        如果通知类(增强类)是一个普通的Java类 就要使用aspect去配置切面
-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!--设置事务的属性信息-->
    <tx:attributes>
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

其中，<tx:method>代表切点方法的事务参数的配置，例如：

<tx:method name="transfer"
           isolation="REPEATABLE_READ"
           propagation="REQUIRED"
           timeout="-1"
           read-only="false"/>
  • name:切点方法名称
  • isolation:事务的隔离级别（REPEATABLE_READ）
  • propagation：事务的传播行为（REQUIRED）
  • timeout:超时时间
  • read-only:是否只读
3、知识要点

声明式事务控制的配置要点：

  • 平台事务管理器
  • 事务通知的配置
  • 事务aop织入的配置

16、基于注解的声明式事务控制

1、使用注解配置声明式事务控制

①编写AccountDao


@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void out(String outMan, double money) {
        jdbcTemplate.update("update account set money=money-? where name =?", money, outMan);
    }

    public void in(String inMan, double money) {
        jdbcTemplate.update("update account set money= money+? where name =?", money, inMan);
    }
}

②编写AccountService

@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRED)
    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan, money);
        int i = 1 / 0;
        accountDao.in(inMan, money);
    }
}

③编写applicationContext.xml配置文件

	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--配置平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
 <!--组件扫描-->
    <context:component-scan base-package="com.itheima"></context:component-scan>
    <!--事务的注解驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
2、注解配置声明式事务控制解析

①使用@Transactional在需要进行事务控制的类或者是方法上修饰，注解可以用的属性同xml配置方法，例如隔离级别、传播行为等；

②注解使用在类上，那么该类下的所有方法都使用同一套注解参数配置；

③使用在方法上，不同的方法可以采用不同的事务参数配置；

④xml配置文件中要配置开启事务的注解驱动<tx:annotation-dariven/>

3、知识要点

注解声明式事务控制的配置要点：

  • 平台事务管理器配置（xml方式）
  • 事务通知的配置（@Transactional注解配置）
  • 事务注解驱动的配置<tx:accotation-driven/>
Coder_lgj
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二、Spring框架
hssf_xxy的博客
10-29 261
1、Spring框架概述 Spring是一个Service层的框架，可以整合许多其他框架进行工作 Spring的主要技术是IOC(DI) AOP IOC(DI) - 控制反转（依赖注入） AOP - 面向切面编程 注意： Spring本身是基于XML配置来工作的，在使用Spring的过程中不可避免的要编写大量的XML配置 Spring官方提供了XML文件的编写规范，通过提供XML约束文件来实现 XML约束文件分为 DTD 后缀为.dtd Schema 后缀为.
Spring简介
qq_45834459的博客
03-30 1万+
一、spring简介 1.1.1 Spring是什么 Spring是分层的 Java SE/EE应用full- stack轻量级开源框架，以IoC(Inversion of Control:反转控制）和AOP( Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC和持久层 Spring JDBC以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE企业应用开源框架。 1.1.2Spr
Spring框架最全知识点
weixin_43515260的博客
09-06 719
Spring框架最全知识点总结
把Spring框架总结的「无比详细」，看完还说不懂别学了
jjc4261的博客
04-14 246
spring这个容器中，替你管理着一系列的类，前提是你需要将这些类交给spring容器进行管理，然后在你需要的时候，不是自己去定义，而是直接向spring容器索取，当spring容器知道你的需求之后，就会去它所管理的组件中进行查找，然后直接给你所需要的组件.3、如果配置基本类的时候，注解和配置文件都使用的时候，注解和配置文件中 name 相同的时候， 则两个冲突，配置文件生效。如果配置基本类的时候，注解和配置文件都使用的时候，注解和配置文件中 name 不相同的时候， 则两个不冲突，都能够生效。
Spring知识点总结 Spring基础到深入(持续更新)
Code_Guan的博客
02-11 5558
Spring知识点总结【非常丰富】基础到深入
Spring框架知识点
08-07
SSM框架
面试知识点总结--Spring 应用框架技术.pdf
01-25
Spring 应用框架技术知识点总结 Spring 是一个流行的 Java 应用框架，它提供了许多功能强大且灵活的技术来帮助开发者快速构建企业级应用程序。下面是 Spring 应用框架技术的知识点总结： 一、Spring 和 Struts 的...
spring框架核心知识点
08-10
spring框架核心知识点
Spring知识点总结大全
最新发布
09-19
Spring框架是Java开发中不可或缺的一部分，它以简化企业级应用程序的构建为目标，通过提供一系列的模块和功能，解决了传统EJB框架存在的诸多问题。本文将深入探讨Spring框架的核心概念、作用以及IoC（控制反转）的...
Spring MVC 框架学习总结
08-18
以上就是 Spring MVC 框架的关键知识点，理解和掌握这些内容对于开发基于 Spring 的 Web 应用程序至关重要。通过深入学习和实践，你可以构建出高效、可维护的 Web 应用程序。在实际项目中，还可以结合 Spring Boot、...
SpringMVC框架各个层的介绍
热门推荐
qq_39299341的博客
04-03 1万+
一.首先，SpringMVC使用分层框架，分层是为了实现“高内聚，低耦合”，把问题划分开来，各个解决，易于控制，延展和分配资源，最重要有利于后期维护项目；MVC指的是model,view,controller;在SpringMVC编程中一般分为四层：1.表示层：（jsp、html 主要就是界面的展示）2.控制层：(Contoller、Action)控制界面跳转3.业务层：(Service)调用DA...
spring(知识点整理,常用，超详细)
咕噜噜的博客
03-23 2702
spring(知识点整理,常用，超详细)
spring 事务管理是在哪一层织入的
樊城城的博客
07-06 8008
dao层 只是对单个数据表的操作，而事务管理的意思是，对都标操作时，有的表成功了，有的没成功，可以促发回滚，
【Spring】框架简介
follow your heart
09-30 353
【Spring】框架简介
Spring面试底层原理的那些问题，你是不是真的懂Spring？
weixin_30663391的博客
06-25 2972
1、什么是 Spring 框架？Spring 框架有哪些主要模块？Spring 框架是一个为 Java 应用程序的开发提供了综合、广泛的基础性支持的 Java 平台。Spring帮助开发者解决了开发中基础性的问题，使得开发人员可以专注于应用程序的开发。Spring 框架本身亦是按照设计模式精心打造，这使得我们可以在开发环境中安心的集成 Spring 框架，不必担心 Spring 是如何在后台进行工...
spring的三层架构
wsong_14的博客
07-29 1万+
分层架构: 面向对象编程-->JavaBean-->Book 和数据库交互 jdbc、hibernate、mybatis(持久化机制) DAO层专门负责数据库交互 CRUD(增查改删) Service层 对于一些业务判断处理， eg:添加图书-->西游记 后传 西游记续 图书名称判断(通过书名进行查询) publi
Spring各层概念解释
weixin_42474632的博客
10-31 3602
https://blog.csdn.net/ma726518972/article/details/80262948 https://blog.csdn.net/u014426726/article/details/95777682
spring各个层之间的工作以及各层之间的联系
wang_666_的博客
04-11 1万+
项目分层：实体层：bean、pojo等用途：和数据库的实体保持一致。数据访问层：dao层，以及到曾的实现类DAO层主要是做数据持久层的工作，负责与数据库进行联络的一些任务都封装在此，DAO层的设计首先是设计DAO的接口，然后在Spring的配置文件中定义此接口的实现类，然后就可在模块中调用此接口来进行数据业务的处理，而不用关心此接口的具体实现类是哪个类，显得结构非常清晰，DAO层的数据源配置，以及...
Spring各层概念与作用介绍
LTtx1的博客
03-10 966
Spring各层概念与作用介绍 entity层=pojo层。 存放我们的属性值，与数据库中的数据表基本保持一致。 model 在Spring MVC中，Controller负责处理DispatcherServlet分发的请求，它把用户请求的数据经业务处理层（service）处理后得到的结果封装成一个Model，然后再把该Model返回给对应的View进行展示。 service层。 存放业务逻辑处理，也是一些关于数据库处理的操作，但不是直接和数据库打交道。它有接口还有接口的实现方法，在接口的实现方法中需要
spring中所需要的知识点及学习方向文档
12-09
掌握这些知识点和学习方向可以帮助大家更好地进行Spring开发。 Spring是一个基于Core来构架多层JavaEE系统的框架，因此在学习Spring时，需要掌握JavaEE技术的基础知识。这包括Java语言基础、Servlet、JSP、JDBC等。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值