目录

1、概述

2、Spring工厂与IOC

2.1、为什么要有Spring框架

2.2、什么是IOC

2、Spring工厂对实例注入

2.1、使用标签进行注入

2.2、使用注解进行注入

2.2.3、Spring常用注解

2.3、基于注解的jdbc实现

2.3.1、maven项目的目录结构

2.3.2、代码片段

2.4、基于XML的jdbc实现

2.4.1、maven项目的目录结构

2.4.2、代码片段

3、Spring事务

3.1、使用ThreadLocal管理Spring事务

4、Spring AOP

4.1、使用AOP动态代理实现方法功能增强的一个demo

4.1.1、使用XML配置

4.1.1、使用注解配置

4.2、Spring AOP实现对方法的事务管理

5、Spring总结

6、参考资料

1、概述

     Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control： 反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架。
 
 

2、Spring工厂与IOC

2.1、为什么要有Spring框架

Spring工厂是一个生产各种类的实例的工厂，Ioc相当于工厂的管理员，负责调度与管理Spring所生产出的各个实例的使用情况。在java编程中，我们往往会使用到许多类，每次使用一个类，我们都必须new 一个它的实例对象，通过这个new出来的实例对象才能调用这个类的成员变量和方法。如果当工程量比较大的话，这样子就很麻烦了，每个类new对象盘根错节。这样就会带来很严重的耦合性。显然这种传统的方式与软件工程所推崇的“高内聚，低耦合”相悖。因此，为了解决这样的耦合性问题。我们引入Spring框架。让Spring工厂为我们创建好实例，我们如果要用到某个类的实例的话，就直接从Spring工厂中拿就行了，不过要注意Spring工厂中默认都是单实例的。

下面看一个简单的Spring工厂生产实例的例子。

2.2、什么是IOC

IOC——Inversion Of Control （控制反转）。就是把创建对象的权利交给框架。它包括依赖注入和依赖查找。IOC不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

IOC容器：IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建，IoC容器控制了对象，主要控制了外部资源获取（不只是对象包括比如文件等）。

IOC反转：所谓的反转就是由容器来帮忙创建及注入依赖对象。因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转。而正转就是由我们自己在对象中主动控制去直接获取依赖对象。

传统的程序设计中都是主动创建类对象。

当有了IoC/DI的容器后，在客户端类中不再主动去创建这些对象了。

IoC不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。IoC很好的体现了面向对象设计法则之一 —— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

2、Spring工厂对实例注入

2.1、使用<bean>标签进行注入

参考代码下载地址：https://gitee.com/wulinchun/ssm-learning/tree/master/       (使用bean进行spring工厂注入代码示例)

bean.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  5.     <!--配置数据源-->
  6.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  7.         <!--连接数据库的必备信息-->
  8.         <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  9.         <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/ssm"></property>
  10.         <property name="user" value="root"></property>
  11.         <property name="password" value="123456"></property>
  12.     </bean>
  14.     <!-- 配置Service -->
  15.     <!--bean的作用范围调整
  16.    bean标签的scope属性
  17.    作用：用于指定bean的作用范围
  18.    取值：
  19.        singleton：单实例（默认值）
  20.        prototype：多实例
  21.        request：作用于web应用的请求范围
  22.        session：作用于web应用的会话范围
  23.        global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session-->
  24.     <!--单例对象
  25.         出生：当容器创建时对象出生
  26.         活着：只要容器还在，对象就一直活着
  27.         死亡：容器销毁，对象消亡
  28.         总结：单例对象的生命周期和容器相同
  29.     多例对象
  30.         出生：当我们使用对象时spring框架为我们创建
  31.         活着：对象只要在使用过程中就一直活着。
  32.         死亡：当对象长时间不用，且没有别的对象引用时，由java的垃圾回收器回收-->
  34.     <!--spring中的依赖注入
  35.     依赖注入：
  36.         Dependency Injection
  37.     IOC的作用：
  38.         降低程序间的耦合（依赖关系）
  39.     依赖关系的管理：
  40.         以后都交给spring来维护
  41.     在当前类徐迎用到其他类的对象，由spring为我们提供，我们只需在配置文件中说明
  42.     依赖关系的维护：
  43.         就称之为依赖注入。
  44.     依赖注入：
  45.         能注入的数据：有三类
  46.               1、基本类型和String
  47.               2、其他bean类型（在配置文件中或者注解配置过的bean)
  48.               3、复杂类型/集合类型
  49.         注入方式：有三种
  50.               1、使用构造函数提供
  51.               2、使用set方法提供
  52.               3、使用注解提供-->
  53.     <bean id="accountService" class="com.spring_demo.service.impl.AccountServiceImpl" scope="prototype">
  54.         <!--property name="accountDao"需要在AccountServiceImpl里面写setAccountDao()方法-->
  55.         <!-- 注入dao -->
  56.         <property name="accountDao" ref="accountDao"></property>
  57.     </bean>
  59.     <!--配置Dao对象-->
  60.     <bean id="accountDao" class="com.spring_demo.dao.impl.AccountDaoImpl">
  61.         <!--property name="runner"需要在AccountDaoImpl里面写setRunner()方法-->
  62.         <!-- 注入QueryRunner -->
  63.         <property name="runner" ref="runner"></property>
  64.     </bean>
  66.     <!--配置QueryRunner-->
  67.     <bean id="runner" class="org.apache.commons.dbutils.QueryRunner">
  68.         <!--注入数据源-->
  69.         <constructor-arg name="ds" ref="dataSource"></constructor-arg>
  70.     </bean>
  72.     <!--构造函数注入：
  73.     使用的标签：constructor-arg
  74.     标签出现的位置：bean标签的内部
  75.     标签中的属性
  76.         type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
  77.         index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值，索引的位置是从0开始
  78.         name：用于提供基本类型和String类型的数据
  79.        ==========================以上三个用于指定给构造函数中哪个参数赋值=======================
  80.        value：用于指定其他的bean类型数据。它指的就是在Spring的IOC核心容器中出现过的bean对象
  81.        ref：用于指定其他的bean类型数据。它指的就是在spring的IOC核心容器中出现过的bean对象
  83.     优势：
  84.        在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功
  85.     弊端：
  86.        改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。-->
  87.     <!--<bean id="user" class="com.spring_demo.domain.User">
  88.         <constructor-arg name="name" value="张三"></constructor-arg>
  89.         &lt;!&ndash;<constructor-arg name="birthday" value="1998-01-10"></constructor-arg>&ndash;&gt;&lt;!&ndash;注意：birthday是date类型，因此这里无法直接配置，要把value改成ref直接参照&ndash;&gt;
  90.         <constructor-arg name="birthday" ref="bir"></constructor-arg>
  91.         <constructor-arg name="age" value="22"></constructor-arg>
  92.     </bean>-->
  94.     <!--set方法注入
  95.        涉及的标签：property
  96.        出现的位置：bean标签的内部
  97.        标签的属性
  98.            name：用于指定注入时所调用的set方法名称
  99.            value：用于指定其他的bean类型数据。它指的就是在Spring的IOC核心容器中出现过的bean对象
  100.            ref：用于指定其他的bean类型数据。它指的就是在spring的IOC核心容器中出现过的bean对象
  101.        优势：
  102.            创建对象时没有明确的限制，可以直接使用默认构造函数
  103.        弊端：
  104.            不能保证某个成员变量必须有值-->
  105.     <bean id="user" class="com.spring_demo.domain.User">
  106.         <property name="name" value="李四"></property>
  107.         <!--<property name="age" value="22"></property>-->
  108.         <property name="birthday" ref="bir"></property>
  109.     </bean>
  111.     <!--复杂类型的注入
  112.     用于给List结构集合注入的标签：list array set
  113.     用于给Map结构集合注入的标签：map props
  114.     结构相同，标签可以互换-->
  115.     <bean id="arraylistsetmap" class="com.spring_demo.domain.ArrayListSetMap">
  116.         <property name="testArray">
  117.             <array>
  118.                 <value>array1</value>
  119.                 <value>array2</value>
  120.                 <value>array3</value>
  121.             </array>
  122.         </property>
  123.         <property name="testList">
  124.             <list>
  125.                 <value>list1</value>
  126.                 <value>list2</value>
  127.                 <value>list3</value>
  128.             </list>
  129.         </property>
  130.         <property name="testSet">
  131.             <set>
  132.                 <value>set1</value>
  133.                 <value>set2</value>
  134.                 <value>set3</value>
  135.             </set>
  136.         </property>
  137.         <property name="testMap">
  138.             <map>
  139.                 <entry key="key1" value="v1"></entry>
  140.                 <entry key="key2" value="v2"></entry>
  141.                 <entry key="key3" value="v3"></entry>
  142.             </map>
  143.         </property>
  144.     </bean>
  146.     <bean id="bir" class="java.util.Date" factory-bean="dateFormat" factory-method="parse">
  147.         <constructor-arg value="1998-01-10"></constructor-arg>
  148.     </bean>
  150.     <bean id="dateFormat" class="java.text.SimpleDateFormat">
  151.         <constructor-arg value="yyyy-MM-dd"></constructor-arg>
  152.     </bean>
  153. </beans>

2.2、使用注解进行注入

参考代码下载地址：https://gitee.com/wulinchun/ssm-learning/tree/master/       (使用annotate进行spring工厂注入代码示例)

bean.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         http://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/context
  8.         http://www.springframework.org/schema/context/spring-context.xsd">
  10.     <!--告知spring在创建容器时要扫描的包，配置所需要的标签不是在beans的约束中，而是一个名称为context名称空间和约束中-->
  11.     <context:component-scan base-package="com.spring_demo_ann"></context:component-scan>
  13. </beans>

2.2.3、Spring常用注解

一、用于创建对象的注解

     相当于：<bean id="" class="">

1、@Component

      作用： 把资源让 spring
来管理。相当于在
xml
中配置一个
bean
。
 
      属性：
value
：指定
bean
的
id
。如果不指定
value
属性，默认
bean
的
id
是当前类的类名。首字母小写。
 
 
2、@Controller @Service @Repository
 

这三个注解都是针对一个的衍生注解，它们的作用及属性都是一模一样的。 它们只不过是提供了更加明确的语义化。

     @Controller：一般用于表现层的注解。
 
     @Service：一般用于业务层的注解。
 
     @Repository：一般用于持久层的注解。
 
     
注：如果注解中有且只有一个属性要赋值时，且名称是 value，value 在赋值时是可以不写。（例如：@Repository(value="userDao")等价于@Repository("userDao")
 
 
 
二、用于注入数据的注解
 
     相当于：<property name="xxx" ref="xxx">
                   <property name="xxx" value="xxx">
 
1、@Autowired
 
    作用： 自动按照类型注入。当使用注解注入属性时，set
方法可以省略。它只能注入其他
bean
类型。当有多个类型匹配时，使用要注入的对象变量名称作为bean
的
id，
在
spring
容器查找，找到了也可以注入
                成功。找不到 就报错。
 
2、@Qualifier
     
   作用：在自动按照类型注入的基础之上，再按照 Bean
的
id
注入。它在给字段注入时不能独立使用，必须和@Autowire一起使用；但是给方法参数注入时，可以独立使用。
   
   属性： value：指定
bean
的
id
。
 
3、@Resource
 

   作用：直接按照 Bean 的 id 注入。它也只能注入其他 bean 类型。

   属性： name：指定 bean 的 id。

 
4、@Value
   
   作用： 注入基本数据类型和 String
类型数据的
 
   属性： value：用于指定值
 
 
 
三、用于改变作用范围的注解
 
      相当于：<bean id="" class="" scope="">
 
1、@Scope
 
     作用： 指定 bean
的作用范围。
 
     属性：
value：指定范围的值。
 
                取值：

singleton：单实例（默认值）

prototype：多实例 request：作用于web应用的请求范围

session：作用于web应用的会话范围

globalsession：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session

四、和生命周期相关的注解

       相当于：<bean id="" class="" init-method="" destroy-method="" />

1、@PostConstruct

      作用： 用于指定初始化方法。
 
2、@PreDestroy
 
      作用： 用于指定销毁方法。
 
 
 
五、用于配置bean和框架的注解
 
   
 用java类实现bean.xml中的配置功能
 
1、@Configuration


     作用：指定当前类是一个配置类。


     细节：当配置类作为AnnotationConfigApplicationContext对象创建的参数时，该注解可以不写。
 
 
2、@ComponentScan


    作用：用于通过注解指定spring在创建容器时要扫描的包。


    属性：value：它和basePackages的作用是一样的，都是用于指定创建容器时要扫描的包。我们使用此注解就等同于在xml中配置了:<context:component-scan base-package="xxx包名"/>
 
 
3、@Bean

   
作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器中。


   属性：name:用于指定bean的id。当不写时，默认值是当前方法的名称。

   
细节：当我们使用注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象。查找的方式和@Autowired注解的作用是一样的。
 
 
4、@Import


   作用：用于导入其他的配置类。


   属性：value：用于指定其他配置类的字节码。当我们使用Import的注解之后，有Import注解的类就父配置类，而导入的都是子配置类。
 


5、@PropertySource


   作用：用于指定properties文件的位置。


   属性：value：指定文件的名称和路径。关键字：classpath，表示类路径下。
 
 
 
 

2.3、基于注解的jdbc实现

参考代码下载地址：https://gitee.com/wulinchun/ssm-learning/tree/master/       (基于注解的jdbc实现代码示例)

2.3.1、maven项目的目录结构

2.3.2、代码片段

AccountDaoImpl.java

  1. package com.spring_demo_ann_JDBC.dao.impl;
  3. import java.sql.SQLException;
  4. import java.util.List;
  6. import org.apache.commons.dbutils.QueryRunner;
  7. import org.apache.commons.dbutils.handlers.BeanListHandler;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Repository;
  11. import com.spring_demo_ann_JDBC.dao.IAccountDao;
  12. import com.spring_demo_ann_JDBC.domain.Account;
  14. /**
  15.  * 持久层接口实现类
  16.  * @author：wu linchun
  17.  * @time：2021/01/17 上午10:32:34
  18.  *
  19.  */
  20. @Repository("accountDao")
  21. public class AccountDaoImpl implements IAccountDao {
  23. 	@Autowired
  24. 	private QueryRunner runner;
  26. 	public List<Account> findAllAccount() {
  27. 		// TODO Auto-generated method stub
  28. 		try {
  29. 			return runner.query("select * from account", new BeanListHandler<Account>(Account.class));
  30. 		} catch (SQLException e) {
  31. 			// TODO Auto-generated catch block
  32. 			e.printStackTrace();
  33. 		}
  34. 		return null;
  35. 	}
  37. 	public Account findAccountById(Integer accountId) {
  38. 		// TODO Auto-generated method stub
  39. 		try {
  40. 			return (Account) runner.query("select * from account where id=?", new BeanListHandler<Account>(Account.class),accountId);
  41. 		} catch (SQLException e) {
  42. 			// TODO Auto-generated catch block
  43. 			e.printStackTrace();
  44. 		}
  45. 		return null;
  46. 	}
  48. 	public void saveAccount(Account account) {
  49. 		// TODO Auto-generated method stub
  50. 		try {
  51. 			runner.update("insert into account values(?,?,?)",account.getId(),account.getName(),account.getMoney());
  52. 		} catch (SQLException e) {
  53. 			// TODO Auto-generated catch block
  54. 			e.printStackTrace();
  55. 		}
  57. 	}
  59. 	public void updateAccount(Account account) {
  60. 		// TODO Auto-generated method stub
  61. 		try {
  62. 			runner.update("update account set id=?,name=?,money=?",account.getId(),account.getName(),account.getMoney());
  63. 		} catch (SQLException e) {
  64. 			// TODO Auto-generated catch block
  65. 			e.printStackTrace();
  66. 		}
  68. 	}
  70. 	public void deleteAccount(Integer accountId) {
  71. 		// TODO Auto-generated method stub
  72. 		try {
  73. 			runner.update("delete from account where id=?",accountId);
  74. 		} catch (SQLException e) {
  75. 			// TODO Auto-generated catch block
  76. 			e.printStackTrace();
  77. 		}
  79. 	}
  81. }

AccountServiceImpl.java

  1. package com.spring_demo_ann_JDBC.service.impl;
  3. import java.util.List;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  8. import com.spring_demo_ann_JDBC.dao.IAccountDao;
  9. import com.spring_demo_ann_JDBC.domain.Account;
  10. import com.spring_demo_ann_JDBC.service.IAccountService;
  12. /**
  13.  * 业务层接口实现类
  14.  * 业务层可以调用持久层所提供的访问数据库方法，并且可以做一些处理。
  15.  * @author：wu linchun
  16.  * @time：2021/01/17 上午11:10:12
  17.  *
  18.  */
  19. @Service("accountService")
  20. public class AccountServiceImpl implements IAccountService {
  22. 	@Autowired
  23. 	private IAccountDao accountDao;
  25. 	public List<Account> findAllAccount() {
  26. 		// TODO Auto-generated method stub
  27. 		/* 业务层可以调用持久层，写业务代码 */
  28. 		/* xxxxxxx */
  29. 		return accountDao.findAllAccount();
  30. 	}
  32. 	public Account findAccountById(Integer accountId) {
  33. 		// TODO Auto-generated method stub
  34. 		return accountDao.findAccountById(accountId);
  35. 	}
  37. 	public void saveAccount(Account account) {
  38. 		// TODO Auto-generated method stub
  39. 		accountDao.saveAccount(account);
  41. 	}
  43. 	public void updateAccount(Account account) {
  44. 		// TODO Auto-generated method stub
  45. 		accountDao.updateAccount(account);
  47. 	}
  49. 	public void deleteAccount(Integer accountId) {
  50. 		// TODO Auto-generated method stub
  51. 		accountDao.deleteAccount(accountId);
  53. 	}
  55. }

JdbcConfig.java

  1. package config;
  3. import javax.sql.DataSource;
  5. import org.apache.commons.dbutils.QueryRunner;
  6. import org.springframework.beans.factory.annotation.Qualifier;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Scope;
  11. import com.mchange.v2.c3p0.ComboPooledDataSource;
  13. /**
  14.  * 和spring连接数据库相关的配置类
  15.  *
  16.  * @author：wu linchun
  17.  * @time：2021/01/17 下午12:24:37
  18.  *
  19.  */
  20. public class JdbcConfig {
  21. 	@Value("${jdbc.driver}")
  22. 	private String driver;
  24. 	@Value("${jdbc.url}")
  25. 	private String url;
  27. 	@Value("${jdbc.username}")
  28. 	private String username;
  30. 	@Value("${jdbc.password}")
  31. 	private String password;
  33. 	/**
  34. 	 * 用于创建一个QueryRunner对象
  35. 	 *
  36. 	 * @param dataSource
  37. 	 * @return
  38. 	 */
  39. 	@Bean(name = "runner")
  40. 	@Scope("prototype")  //多实例
  41. 	public QueryRunner createQueryRunner(@Qualifier("ds2") DataSource dataSource) {
  42. 		return new QueryRunner(dataSource);
  43. 	}
  45. 	/**
  46. 	 * 创建数据源对象
  47. 	 *
  48. 	 * @return
  49. 	 */
  50. 	@Bean(name = "ds2")
  51. 	public DataSource createDataSource() {
  52. 		try {
  53. 			ComboPooledDataSource ds = new ComboPooledDataSource();
  54. 			ds.setDriverClass(driver);
  55. 			ds.setJdbcUrl(url);
  56. 			ds.setUser(username);
  57. 			ds.setPassword(password);
  58. 			return ds;
  59. 		} catch (Exception e) {
  60. 			throw new RuntimeException(e);
  61. 		}
  62. 	}
  64. 	/*@Bean(name = "ds1")
  65. 	public DataSource createDataSource1() {
  66. 		try {
  67. 			ComboPooledDataSource ds = new ComboPooledDataSource();
  68. 			ds.setDriverClass(driver);
  69. 			ds.setJdbcUrl("jdbc:mysql://localhost:3306/ssm");
  70. 			ds.setUser(username);
  71. 			ds.setPassword(password);
  72. 			return ds;
  73. 		} catch (Exception e) {
  74. 			throw new RuntimeException(e);
  75. 		}
  76. 	}*/
  77. }
SpringConfiguration.java 
  1. package config;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.Import;
  6. import org.springframework.context.annotation.PropertySource;
  8. @Configuration
  9. @ComponentScan("com.spring_demo_ann_JDBC")
  10. @Import(JdbcConfig.class)
  11. @PropertySource("classpath:jdbcConfig.properties")
  12. public class SpringConfiguration {
  14. }

jdbcConfig.properties

  1. jdbc.driver=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql://localhost:3306/ssm
  3. jdbc.username=root
  4. jdbc.password=123456

 

2.4、基于XML的jdbc实现

参考代码下载地址：https://gitee.com/wulinchun/ssm-learning/tree/master/       (基于xml的jdbc实现代码示例)

2.4.1、maven项目的目录结构

 
 

2.4.2、代码片段

AccountDaoImpl.java

  1. package com.spring_demo_xml_JDBC.dao.impl;
  3. import java.sql.SQLException;
  4. import java.util.List;
  6. import org.apache.commons.dbutils.QueryRunner;
  7. import org.apache.commons.dbutils.handlers.BeanHandler;
  8. import org.apache.commons.dbutils.handlers.BeanListHandler;
  10. import com.spring_demo_xml_JDBC.dao.IAccountDao;
  11. import com.spring_demo_xml_JDBC.domain.Account;
  13. /**
  14.  * 持久层实现类
  15.  *
  16.  * @author：wu linchun
  17.  * @time：2020-01-15下午5:01:29
  18.  */
  19. public class AccountDaoImpl implements IAccountDao {
  21.     private QueryRunner runner;
  23.     public AccountDaoImpl(QueryRunner runner) {
  24.         super();
  25.         this.runner = runner;
  26.     }
  28.     public List<Account> findAllAccount() {
  29.         // TODO Auto-generated method stub
  30.         try {
  31.             return runner.query("select * from account", new BeanListHandler<Account>(Account.class));
  32.         } catch (SQLException e) {
  33.             // TODO Auto-generated catch block
  34.             e.printStackTrace();
  35.         }
  36.         return null;
  37.     }
  39.     public Account findAccountById(Integer accountId) {
  40.         // TODO Auto-generated method stub
  41.         try {
  42.             return (Account) runner.query("select * from account where id=?",
  43.                     new BeanHandler<Account>(Account.class), accountId);
  44.         } catch (SQLException e) {
  45.             // TODO Auto-generated catch block
  46.             e.printStackTrace();
  47.         }
  48.         return null;
  49.     }
  51.     public void saveAccount(Account account) {
  52.         // TODO Auto-generated method stub
  53.         try {
  54.             runner.update("insert into account values(?,?,?)", account.getId(), account.getName(), account.getMoney());
  55.         } catch (SQLException e) {
  56.             // TODO Auto-generated catch block
  57.             e.printStackTrace();
  58.         }
  60.     }
  62.     public void updateAccount(Account account) {
  63.         // TODO Auto-generated method stub
  64.         try {
  65.             runner.update("update account set name=?,money=? where id=?", account.getName(),
  66.                     account.getMoney(), account.getId());
  67.         } catch (SQLException e) {
  68.             // TODO Auto-generated catch block
  69.             e.printStackTrace();
  70.         }
  72.     }
  74.     public void deleteAccount(Integer accountId) {
  75.         // TODO Auto-generated method stub
  76.         try {
  77.             runner.update("delete from account where id=?", accountId);
  78.         } catch (SQLException e) {
  79.             // TODO Auto-generated catch block
  80.             e.printStackTrace();
  81.         }
  83.     }
  85. }

AccountServiceImpl.java

  1. package com.spring_demo_xml_JDBC.service.impl;
  3. import java.util.List;
  5. import com.spring_demo_xml_JDBC.dao.IAccountDao;
  6. import com.spring_demo_xml_JDBC.domain.Account;
  7. import com.spring_demo_xml_JDBC.service.IAccountService;
  9. /**
  10.  *
  11.  * @author：wu linchun
  12.  * @time：2020-01-15下午4:56:23
  13.  *
  14.  */
  15. public class AccountServiceImpl implements IAccountService {
  17. 	private IAccountDao accountDao;
  19. 	public void setAccountDao(IAccountDao accountDao) {
  20. 		this.accountDao = accountDao;
  21. 	}
  23. 	public List<Account> findAllAccount() {
  24. 		// TODO Auto-generated method stub
  25. 		/* 业务层可以调用持久层，写业务代码 */
  26. 		/* xxxxxxx */
  27. 		return accountDao.findAllAccount();
  28. 	}
  30. 	public Account findAccountById(Integer accountId) {
  31. 		// TODO Auto-generated method stub
  32. 		return accountDao.findAccountById(accountId);
  33. 	}
  35. 	public void saveAccount(Account account) {
  36. 		// TODO Auto-generated method stub
  37. 		accountDao.saveAccount(account);
  39. 	}
  41. 	public void updateAccount(Account account) {
  42. 		// TODO Auto-generated method stub
  43. 		accountDao.updateAccount(account);
  45. 	}
  47. 	public void deleteAccount(Integer accountId) {
  48. 		// TODO Auto-generated method stub
  49. 		accountDao.deleteAccount(accountId);
  51. 	}
  52. }

QueryRunnerTest.java

  1. package spring_demo_xml_JDBC;
  3. import java.util.List;
  5. import org.junit.Test;
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. import org.springframework.context.support.FileSystemXmlApplicationContext;
  9. import com.spring_demo_xml_JDBC.domain.Account;
  10. import com.spring_demo_xml_JDBC.service.impl.AccountServiceImpl;
  12. /**
  13.  *
  14.  * @author：wu linchun
  15.  * @time：2020/01/15 下午5:33:43
  16.  *
  17.  */
  18. public class QueryRunnerTest {
  19. 	ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
  20. 	AccountServiceImpl as=(AccountServiceImpl)ac.getBean("accountService");
  22. 	/**
  23. 	 * 测试是否可以获取bean配置
  24. 	 */
  25. 	@Test
  26. 	public void testBeanXml() {
  27. 		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
  28. 		ClassPathXmlApplicationContext applicationContext1 = new ClassPathXmlApplicationContext("bean.xml");
  29. 		/*
  30. 		 * FileSystemXmlApplicationContext applicationContext=new
  31. 		 * FileSystemXmlApplicationContext("C:\\Program Files\\eclipse-workspace\\spring_demo_xml_JDBC\\src\\main\\resources\\bean.xml"
  32. 		 * );
  33. 		 */
  34. 		/*
  35. 		 * FileSystemXmlApplicationContext applicationContext1=new
  36. 		 * FileSystemXmlApplicationContext("C:\\Program Files\\eclipse-workspace\\spring_demo_xml_JDBC\\src\\main\\resources\\bean.xml"
  37. 		 * );
  38. 		 */
  39. 		System.out.println(applicationContext.toString());
  40. 		System.out.println(applicationContext == applicationContext1);
  41. 	}
  43. 	@Test
  44. 	public void testFindAll() {
  45. 		// 3.执行方法
  46. 		List<Account> accounts = as.findAllAccount();
  47. 		for (Account account : accounts) {
  48. 			System.out.println(account);
  49. 		}
  50. 	}
  52. 	@Test
  53. 	public void testFindAccountById(){
  54. 		Account account=as.findAccountById(1);
  55. 		System.out.println(account.toString());
  56. 	}
  58. 	@Test
  59. 	public void testSaveAccount(){
  60. 		Account account=new Account(7,"ggg",1000f);
  61. 		as.saveAccount(account);
  62. 	}
  64. 	@Test
  65. 	public void testUpdateAccount(){
  66. 		Account account=new Account(7,"ggg",2000f);
  67. 		as.updateAccount(account);
  68. 	}
  70. 	@Test
  71. 	public void testDeleteAccount(){
  72. 		as.deleteAccount(7);
  73. 	}
  75. }

 

3、Spring事务

事务:是逻辑上一组操作，要么全都成功，要么全都失败。事务包含：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）

  • 原子性（Atomicity）:事务不可分割
  • 一致性（Consistency）:事务执行的前后，数据完整性保持一致
  • 隔离性（Isolation）:一个事务执行的时候，不应该受到其他事务的打扰
  • 持久性（Durability）:一旦结束，数据就永久的保存到数据库

3.1、使用ThreadLocal管理Spring事务

这里只展示一个demo，使用ThreadLocal管理Spring事务，实现事务回滚，确保数据的一致性。关于ThreadLocal类的更多详细请看  https://www.zhihu.com/question/341005993

这是一个实现转账的功能

正常情况下，是账户aaa少了200，账户bbb增加了200
 

 
 
但是如果在转账过程中，出现了异常，就会导致数据的不一致性。
 

 

 

为了解决这个问题，就必须使用事务回滚机制，即在发生异常时，将已经修改了的数据进行回滚，使数据恢复到原来的状态。

关键代码

MyConnectionUtils.java

  1. package com.spring_demo_routine.utils;
  3. import org.springframework.stereotype.Service;
  5. import java.sql.Connection;
  7. import javax.sql.DataSource;
  8. import java.sql.SQLException;
  10. /**
  11.  * @description: 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定
  12.  * @author: wu linchun
  13.  * @time: 2021/1/16 11:58
  14.  */
  16. public class MyConnectionUtils {
  18.     //ThreadLocal作用主要是做线程隔离，确保线程安全。
  19.     //Spring采用Threadlocal的方式，来保证单个线程中的数据库操作使用的是同一个数据库连接。
  20.     //如果某个用户频繁使用数据库，那么就需要建立多次链接和关闭，服务器可能会吃不消
  21.     //ThreadLocal可以为每一个用户单独创建一个连接对象，这样就不必该用户每次访问数据库JVM都给new一个连接对象了。
  22.     private ThreadLocal<Connection> t1=new ThreadLocal<Connection>();
  23.     private DataSource dataSource;
  25.     public void setDataSource(DataSource dataSource) {
  26.         this.dataSource = dataSource;
  27.     }
  29.     /**
  30.      * 获取当前线程上的连接
  31.      * @return
  32.      * @throws SQLException
  33.      */
  34.     public Connection getThreadConnection() throws SQLException {
  35.         //先从ThreadLocal上获取
  36.         Connection conn=t1.get();
  37.         //判断当前线程上是否有连接
  38.         if(conn==null){
  39.             //从数据源中获取一个连接，并且存入ThreadLocal中
  40.             conn=dataSource.getConnection();
  41.             t1.set(conn);
  42.         }
  43.         //返回当前线程上的连接
  44.         return conn;
  45.     }
  47.     /**
  48.      * 把连接和线程解绑
  49.      */
  50.     public void removeConnection(){
  51.         t1.remove();
  52.     }
  53. }

AccountDaoImpl.java

  1. package com.spring_demo_routine.dao.impl;
  3. import com.mchange.v1.db.sql.ConnectionUtils;
  4. import com.spring_demo_routine.dao.IAccountDao;
  5. import com.spring_demo_routine.domain.Account;
  6. import com.spring_demo_routine.utils.MyConnectionUtils;
  7. import org.apache.commons.dbutils.QueryRunner;
  8. import org.apache.commons.dbutils.handlers.BeanHandler;
  9. import org.apache.commons.dbutils.handlers.BeanListHandler;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.stereotype.Repository;
  13. import java.sql.SQLException;
  14. import java.util.List;
  16. /**
  17.  * @description: 账户接口实现类
  18.  * @author: wu linchun
  19.  * @time: 2021/1/16 11:53
  20.  */
  22. public class AccountDaoImpl implements IAccountDao {
  24.     private QueryRunner runner;
  26.     private MyConnectionUtils connectionUtils;
  28.     public void setRunner(QueryRunner runner) {
  29.         this.runner = runner;
  30.     }
  32.     public void setConnectionUtils(MyConnectionUtils connectionUtils) {
  33.         this.connectionUtils = connectionUtils;
  34.     }
  36.     public List<Account> findAllAccount() throws SQLException {
  37.         return runner.query(connectionUtils.getThreadConnection(),"select * from account",new BeanListHandler<Account>(Account.class));
  38.     }
  40.     public Account findAccountById(Integer accountId) throws SQLException {
  41.         return runner.query(connectionUtils.getThreadConnection(),"select * from account where id=?",new BeanHandler<Account>(Account.class));
  42.     }
  44.     public void saveAccount(Account account) throws SQLException {
  45.         runner.update(connectionUtils.getThreadConnection(),"insert into account(id,name,money) values(?,?,?)",account.getId(),account.getName(),account.getMoney());
  46.     }
  48.     public void updateAccount(Account account) throws SQLException {
  49.         runner.update(connectionUtils.getThreadConnection(),"update account set name=?, money=? where id=?",account.getName(),account.getMoney(),account.getId());
  50.     }
  52.     public void deleteAccount(Integer acccountId) throws SQLException {
  53.         runner.update(connectionUtils.getThreadConnection(),"delete from account where id=?",acccountId);
  54.     }
  56.     public Account findAccountByName(String accountName) throws SQLException {
  57.         return runner.query(connectionUtils.getThreadConnection(),"select * from account where name = ?",new BeanHandler<Account>(Account.class),accountName);
  58.     }
  59. }

beam.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.         http://www.springframework.org/schema/beans/spring-beans.xsd">
  7.     <!-- 配置Service -->
  8.     <bean id="accountService" class="com.spring_demo_routine.service.impl.AccountServiceImpl">
  9.         <!-- 注入dao -->
  10.         <property name="accountDao" ref="accountDao"></property>
  11.     </bean>
  13.     <!--配置Dao对象-->
  14.     <bean id="accountDao" class="com.spring_demo_routine.dao.impl.AccountDaoImpl">
  15.         <!-- 注入QueryRunner -->
  16.         <property name="runner" ref="runner"></property>
  17.         <!-- 注入ConnectionUtils -->
  18.         <property name="connectionUtils" ref="connectionUtils"></property>
  19.     </bean>
  21.     <!--配置QueryRunner-->
  22.     <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"></bean>
  24.     <!-- 配置数据源 -->
  25.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  26.         <!--连接数据库的必备信息-->
  27.         <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  28.         <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/ssm"></property>
  29.         <property name="user" value="root"></property>
  30.         <property name="password" value="19980319"></property>
  31.     </bean>
  33.     <!-- 配置Connection的工具类 ConnectionUtils -->
  34.     <bean id="connectionUtils" class="com.spring_demo_routine.utils.MyConnectionUtils">
  35.         <!-- 注入数据源-->
  36.         <property name="dataSource" ref="dataSource"></property>
  37.     </bean>
  39. </beans>

发生异常后数据回滚，不会修改

参考代码下载地址：https://gitee.com/wulinchun/ssm-learning/tree/master/       （ssm——spring整理——spring事务（ThreadLocal））

4、Spring AOP

AOP
：全称是
Aspect Oriented Programming 即：面向切面编程。AOP可以把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。
 

AOP的作用及优势：

作用： AOP使用动态代理实现，在程序运行期间，可以在不修改源码的情况下对已有方法进行增强。
优势： 减少重复代码 、提高开发效率 、维护方便。
 
 

4.1、使用AOP动态代理实现方法功能增强的一个demo

参考代码下载地址：https://gitee.com/wulinchun/ssm-learning/tree/master/       （ssm——spring整理——springAOP（xml配置））

4.1.1、使用XML配置

关键代码

AccountServiceImpl.java

  1. package com.spring_AOP_xml_demo.service.impl;
  3. import com.spring_AOP_xml_demo.domain.Account;
  4. import com.spring_AOP_xml_demo.service.IAccountService;
  6. /**
  7.  * @description: 业务层实现接口
  8.  * @author: wu linchun
  9.  * @time: 2021/1/17 14:12
  10.  */
  12. public class AccountServiceImpl implements IAccountService {
  13.     /**
  14.      * 要被增强的方法：给saveAccount，updateAccount，deleteAccount方法都增加一个打印日志的功能
  15.      */
  16.     public void saveAccount() {
  17.         System.out.println("执行了保存账户");
  18.     }
  20.     public void updateAccount(Account account) {
  21.         System.out.println("执行了修改账户");
  22.     }
  24.     public void deleteAccount() {
  25.         System.out.println("执行了删除账户");
  26.     }
  27. }
MyLogger.java 
  1. package com.spring_AOP_xml_demo.utils;
  3. /**
  4.  * @description: 模拟日志打印
  5.  * @author: wu linchun
  6.  * @time: 2021/1/17 14:07
  7.  */
  9. public class MyLogger {
  10.     public void printLog(){
  11.         System.out.println("打印了日志");
  12.     }
  14. }

bean.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         http://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/aop
  8.         http://www.springframework.org/schema/aop/spring-aop.xsd">
  10.     <bean id="iaccountService" class="com.spring_AOP_xml_demo.service.IAccountService" abstract="true"></bean>
  12.     <bean id="accountService" class="com.spring_AOP_xml_demo.service.impl.AccountServiceImpl"></bean>
  14.     <bean id="mylogger" class="com.spring_AOP_xml_demo.utils.MyLogger"></bean>
  16.     <!-- &lt;!&ndash;配置AOP&ndash;&gt;
  17.      <aop:config>
  18.          &lt;!&ndash;配置切面&ndash;&gt;
  19.          <aop:aspect id="logAdvice" ref="mylogger">
  20.              &lt;!&ndash; 配置通知的类型，并且建立通知方法和切入点方法的关联(指定类指定方法）&ndash;&gt;
  21.              <aop:after method="printLog" pointcut="execution(public void com.spring_AOP_xml_demo.service.impl.AccountServiceImpl.saveAccount())"></aop:after>
  22.          </aop:aspect>
  23.      </aop:config>-->
  25.     <!--配置AOP-->
  26.     <aop:config>
  27.         <!--配置切面-->
  28.         <aop:aspect id="logAdvice" ref="mylogger">
  29.             <!-- 配置通知的类型，并且建立通知方法和切入点方法的关联（指定类中的所有方法)-->
  30.             <aop:after method="printLog"
  31.                        pointcut="execution(* com.spring_AOP_xml_demo.service.impl.*.*(..))"></aop:after>
  32.         </aop:aspect>
  33.     </aop:config>
  35. </beans>

测试一下：

  1. package spring_AOP_xml_demo;
  3. import com.spring_AOP_xml_demo.domain.Account;
  4. import com.spring_AOP_xml_demo.service.IAccountService;
  5. import com.spring_AOP_xml_demo.service.impl.AccountServiceImpl;
  6. import org.junit.Test;
  7. import org.springframework.context.support.ClassPathXmlApplicationContext;
  9. /**
  10.  * @description: AOP测试
  11.  * @author: wu linchun
  12.  * @time: 2021/1/17 14:38
  13.  */
  15. public class AopTest {
  16.     ClassPathXmlApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
  17.     //AccountServiceImpl as= (AccountServiceImpl) ac.getBean("accountService");
  18.     //注意！！！这里要用IAccountService声明，不能使用AccountServiceImpl,否则会报类型转换异常
  19.     // 因为AccountServiceImpl实现接口IAccountService，但并没有注入接口IAccountService
  20.     IAccountService ias=(IAccountService)ac.getBean("accountService");
  21.     Account account=new Account();
  22.     @Test
  23.     public void testSaveAccount(){
  24.         //as.saveAccount();
  25.         ias.saveAccount();
  26.     }
  28.     @Test
  29.     public void testUpdateAccount(){
  31.         ias.updateAccount(account);
  32.     }
  34.     @Test
  35.     public void testDeleteAccount(){
  36.         ias.deleteAccount();
  37.     }
  39.     @Test
  40.     public void testAll(){
  41.         ias.saveAccount();
  42.         ias.updateAccount(account);
  43.         ias.deleteAccount();
  44.     }
  45. }

关于AOP配置步骤说明：

1、把通知类用 bean 标签配置起来

2、使用aop:config标签表明开始AOP的配置。

3、使用aop:aspect标签表明配置切面。id属性：是给切面提供一个唯一标识 。ref属性：是指定通知类bean的Id。

4、使用 aop:pointcut 配置切入点表达式。expression属性：用于定义切入点表达式。 id属性：用于给切入点表达式提供一个唯一标识。

5、使用 aop:xxx 配置对应的通知类型。aop:before：前置通知。 aop:after：后置通知。 aop:around：环绕通知（可以手动控制增强代码什么时候执行）。

4.1.1、使用注解配置

参考代码下载地址：https://gitee.com/wulinchun/ssm-learning/tree/master/       （ssm——spring整理——springAOP（注解配置））

关键代码

SpringConfiguration.java

  1. package config;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.EnableAspectJAutoProxy;
  7. /**
  8.  *
  9.  * 配置类
  10.  * @author：wu linchun
  11.  * @time：2021/01/18下午2:12:07
  12.  *
  13.  */
  14. @Configuration
  15. @ComponentScan(basePackages="com.spring_AOP_annotation_demo")
  16. @EnableAspectJAutoProxy
  17. public class SpringConfiguration {
  19. }

MyLogger.java

  1. package com.spring_AOP_annotation_demo.utils;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.After;
  5. import org.aspectj.lang.annotation.AfterReturning;
  6. import org.aspectj.lang.annotation.Around;
  7. import org.aspectj.lang.annotation.Aspect;
  8. import org.aspectj.lang.annotation.Before;
  9. import org.aspectj.lang.annotation.Pointcut;
  10. import org.springframework.stereotype.Component;
  12. /**
  13.  *
  14.  * 用于记录日志的工具类，它里面提供了公共的代码
  15.  *
  16.  * @author：wu linchun
  17.  * @time：2021/01/18上午10:51:37
  18.  *
  19.  */
  20. @Component("mylogger")
  21. @Aspect // 表示当前类是一个切面类
  22. public class MyLogger {
  24. 	// 配置切入点
  25. 	@Pointcut("execution(* com.spring_AOP_annotation_demo.service.impl.*.*(..))")
  26. 	private void pt1() {
  27. 	}
  29. 	/**
  30. 	 * 前置通知
  31. 	 */
  32. 	@Before("pt1()")
  33. 	public void beforePrintLog() {
  34. 		System.out.println("前置通知MyLogger类中beforePrintLog()打印了日志");
  35. 	}
  37. 	// 后置通知和异常通知是互斥的，spring基于注解的AOP配置中，这四个通知类型的调用确实有顺序问题。
  39. 	/**
  40. 	 * 后置通知
  41. 	 */
  43. 	@AfterReturning("pt1()")
  44. 	public void afterPrintLog() {
  45. 		System.out.println("后置通知MyLogger类中afterPrintLog()打印了日志");
  46. 	}
  48. 	/**
  49. 	 * 最终通知
  50. 	 */
  52. 	@After("pt1()")
  53. 	public void finalPrintLog() {
  54. 		System.out.println("最终通知MyLogger类中的afterPrintLog方法开始记录日志了。。。");
  55. 	}
  57. 	/**
  58. 	 * 环绕通知 问题： 当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。 分析：
  59. 	 * 通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。 解决：
  60. 	 * Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。
  61. 	 * 该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
  62. 	 *
  63. 	 * spring中的环绕通知： 它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
  64. 	 * @throws Throwable
  65. 	 */
  66. 	@Around("pt1()")
  67. 	public void aroundPringLog(ProceedingJoinPoint pjp) throws Throwable {
  68. 		System.out.println("环绕通知——前置通知MyLogger类中beforePrintLog()打印了日志");
  69. 		pjp.proceed();   //被功能增强的程序执行
  70. 		System.out.println("环绕通知——后置通知MyLogger类中beforePrintLog()打印了日志");
  72. 	}
  74. }

AccountServiceImpl.java

  1. package com.spring_AOP_annotation_demo.service.impl;
  3. import org.springframework.stereotype.Service;
  5. import com.spring_AOP_annotation_demo.service.IAccountService;
  6. /**
  7.  *
  8.  *
  9.  * @author：wu linchun
  10.  * @time：2021/01/18上午10:57:15
  11.  *
  12.  */
  13. @Service("accountService")
  14. public class AccountServiceImpl implements IAccountService {
  16. 	public void saveAccount() {
  17. 		// TODO Auto-generated method stub
  18. 		System.out.println("执行了保存");
  20. 	}
  22. 	public void updateAccount(int i) {
  23. 		// TODO Auto-generated method stub
  24. 		System.out.println("执行了更新");
  26. 	}
  28. 	public int deleteAccount() {
  29. 		// TODO Auto-generated method stub
  30. 		System.out.println("执行了删除");
  31. 		return 0;
  32. 	}
  34. }

注意：后置通知和异常通知是互斥的，spring基于注解的AOP配置中，这四个通知类型的调用确实有顺序问题。所以如果使用注解配置AOP，建议使用环绕通知的方式，确保顺序正确。

4.2、Spring AOP实现对方法的事务管理

参考代码下载地址：https://gitee.com/wulinchun/ssm-learning/tree/master/    （ssm——spring整理——使用 AOP实现对方法的事务管理）

5、Spring总结

这篇文章是通过学习b站上ssm视频课程，然后对一些知识点做了一些整理。无论是mybatis还是spring，框架的出现除了简化编程少写些代码，最终目的是为了线程安全。解决在大量频繁访问的情况下，确保服务器的JVM能够正常运行。在面向对象的程序中，不可避免会引用到许多的对象，以java为例，如果每次用到某个类的话，都需new一个对象，而new一个对象就相当于在内存中开辟一块空间。当程序足够复杂，需要new的对象足够多时，显然程序每次运行时new的对象都会占据内存的很大一部分空间。虽然JVM有着良好高效的垃圾回收机制，但是如果是大量的，频繁的操作，显然会导致服务器的内存空间在短时间内迅速被占满。这就会影响系统的性能，甚至造成死锁，服务器宕机。虽然框架中，spring工厂中的对象还是会在内存中预占有相当的空间，但是工厂中的对象是共享的，可以用“共享单车”来类比一下。对象相当于自行车，不需要每个人都要自己买一部自行车，每个人不是在任何时候都会使用到自行车。将自行车放在工厂中，需要的话由IOC统一配给，用完再还回去。显然当程序日益复杂，业务日益庞大的时候，如何优化调度，确保资源能被最大化利用，确保资源能被及时配给，这就是框架所需不断升级改进的地方。

6、参考资料

  1. https://www.cnblogs.com/NancyStartOnce/p/6813162.html
  2. https://www.zhihu.com/question/20794107
  3. https://www.zhihu.com/question/341005993

ssm——spring整理的更多相关文章

  1. maven/eclipse搭建ssm(spring+spring mvc+mybatis)

    maven/eclipse搭建ssm(spring+spring mvc+mybatis) 前言 本文旨在利用maven搭建ssm环境,而关于maven的具体内容,大家可以去阅读<Maven 实 ...

  2. SSM Spring+SpringMVC+mybatis+maven+mysql环境搭建

    SSM Spring+SpringMVC+mybatis+maven环境搭建 1.首先右键点击项目区空白处,选择new->other..在弹出框中输入maven,选择Maven Project. ...

  3. SSM(Spring + Springmvc + Mybatis)框架面试题

    JAVA SSM框架基础面试题https://blog.csdn.net/qq_39031310/article/details/83050192 SSM(Spring + Springmvc + M ...

  4. SSM(Spring +SpringMVC + Mybatis)框架搭建

    SSM(Spring +SpringMVC + Mybatis)框架的搭建 最近通过学习别人博客发表的SSM搭建Demo,尝试去搭建一个简单的SSMDemo---实现的功能是对用户增删改查的操作 参考 ...

  5. SSM(Spring+SpringMVC+Mybatis)框架环境搭建(整合步骤)(一)

    1. 前言 最近在写毕设过程中,重新梳理了一遍SSM框架,特此记录一下. 附上源码:https://gitee.com/niceyoo/jeenotes-ssm 2. 概述 在写代码之前我们先了解一下 ...

  6. SSM Spring +SpringMVC+Mybatis 整合配置 及pom.xml

    SSM Spring +SpringMVC+Mybatis 配置 及pom.xml SSM框架(spring+springMVC+Mybatis) pom.xml文件 maven下的ssm整合配置步骤

  7. SSM(Spring,SpringMVC,Mybatis)框架整合项目

    快速上手SSM(Spring,SpringMVC,Mybatis)框架整合项目 环境要求: IDEA MySQL 8.0.25 Tomcat 9 Maven 3.6 数据库环境: 创建一个存放书籍数据 ...

  8. SSM:spring+springmvc+mybatis框架中的XML配置文件功能详细解释（转）

    原文:https://blog.csdn.net/yijiemamin/article/details/51156189# 这几天一直在整合SSM框架,虽然网上有很多已经整合好的,但是对于里面的配置文 ...

  9. SSM:spring+springmvc+mybatis框架中的XML配置文件功能详细解释

    这几天一直在整合SSM框架,虽然网上有很多已经整合好的,但是对于里面的配置文件并没有进行过多的说明,很多人知其然不知其所以然,经过几天的搜索和整理,今天总算对其中的XML配置文件有了一定的了解,所以拿 ...

  10. ssm(spring,springmvc,mybatis)

    1.配置web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app version=&qu ...

随机推荐

  1. POJ1185 [NOI2001] 炮兵阵地 （状压DP）

    又是一道有合法性检测的状压题. dp[i][j][k]表示第i行状态为j,i-1行状态为k时前i行放置的最大数量. 注意22行统计二进制数中1的个数时的巧妙方法. 1 #include<cstd ...

  2. 洛谷P2880 [USACO07JAN] Balanced Lineup G（树状数组/线段树）

    维护区间最值的模板题. 1.树状数组 1 #include<bits/stdc++.h> 2 //树状数组做法 3 using namespace std; 4 const int N=5 ...

  3. 15 Uncaught TypeError: Cannot set properties of null (setting ‘onclick‘)

    1.报错的代码 <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <t ...

  4. "一键重装系统软件"操作流程

    博主之前重装系统都是直接用win10系统更新里的重置系统(版本不会变化),和U盘重装电脑出厂映像(有各种品牌自带的软件,而且由于是出场版本,版本很低) 所以这次用"小白一键重装系统" ...

  5. 1.Python面向对象基础

    面向对象(OOP) 面向对象编程--object oriented programming 简写 OOP   面向过程和面向对象的区别: 面向过程: 1.把完成某一个需求的所有步骤从头到尾逐步实现 2 ...

  6. wpf下的图片放大缩小

    WPF下实现图片的放大缩小移动   在windows 7里面有自带的图片查看器,这个软件可以打开一张图片然后以鼠标在图片中的焦点为原点来进行缩放,并且放大后可以随意拖动.下面我们在WPF中实现这个功能 ...

  7. Linux系统命令基础

    Linux系统命令基础 前面咱们已经成功安装了Linux系统--centos7,那么现在奔向Linux命令行的世界. Linux命令格式 1.一般情况下,[参数]是可选的,一些情况下[文件或路径]也是 ...

  8. Codeforces Round #812 (Div. 2) E（并查集）

    种类并查集:定义种类之间的关系来判断操作是否进行 题目大意:对于题目给出的一个矩阵,我们可以进行一种操作:swap(a[i][j],a[j][i]) 使得矩阵可以变换为字典序最小的矩阵 思路: 通过扫 ...

  9. JUC学习笔记——共享模型之内存

    JUC学习笔记--共享模型之内存 在本系列内容中我们会对JUC做一个系统的学习,本片将会介绍JUC的内存部分 我们会分为以下几部分进行介绍: Java内存模型 可见性 模式之两阶段终止 模式之Balk ...

  10. Java-（array）数组的基本概念 及 Java内存划分

    (array)数组的基本概念 数组的概念:是一种容器,可同时存放多个数据值 数组的特点: 1.数组是一种引用数据类型 2.数组当中的多个数据,类型必须统一 3.数组的长度在程序运行期间不可改变 数组的 ...