概述
Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 SpringMVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架。
IoC 的概念和作用
程序的耦合和解耦
程序的耦合
public class AccountServiceImpl implements IAccountService { private IAccountDao accountDao = new AccountDaoImpl(); }上面的代码表示：
业务层调用持久层，并且此时业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类，编译将不能通过。 这种编译期依赖关系，应该在我们开发中杜绝。 我们需要优化代码解决。
解决程序耦合的思路
jdbc 中，是通过反射来注册驱动的，代码如下：
Class.forName("com.mysql.jdbc.Driver");//此处只是一个字符串此时的好处是，我们的类中不再依赖具体的驱动类，此时就算删除 mysql 的驱动 jar 包，依然可以编译（运行就不要想了，没有驱动不可能运行成功的） 。
同时，也产生了一个新的问题， mysql 驱动的全限定类名字符串是在 java 类中写死的，一旦要改还是要修改
源码。解决这个问题也很简单，使用配置文件配置。
工厂模式解耦
在实际开发中可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候， 让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。
那么，这个读取配置文件， 创建和获取三层对象的类就是工厂。
控制反转-Inversion Of Control
上一小节解耦的思路有 2 个问题：
存哪去？
分析：由于我们是很多对象，肯定要找个集合来存。这时候有 Map 和 List 供选择。
到底选 Map 还是 List 就看我们有没有查找需求。有查找需求，选 Map。所以我们的答案就是
在应用加载时，创建一个 Map，用于存放三层对象。
我们把这个 map 称之为容器。什么是工厂？
工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。
- 原来：
- 我们在获取对象时，都是采用 new 的方式。 是主动的。
- 现在：
- 我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。 是被动的。
使用 spring 的 IOC 解耦
环境搭建
准备 spring 的开发包
- 官网： http://spring.io/
- 下载地址：
http://repo.springsource.org/libs-release-local/org/springframework/spring
创建业务层接口和实现类
public interface IAccountService { /** * 保存账户（此处只是模拟，并不是真的要保存） */ void saveAccount(); } public class AccountServiceImpl implements IAccountService { private IAccountDao accountDao = new AccountDaoImpl();//此处的依赖关系有待解决 @Override public void saveAccount() { accountDao.saveAccount(); } }创建持久层接口和实现类
public interface IAccountDao { /** * 保存账户 */ void saveAccount(); } public class AccountDaoImpl implements IAccountDao { @Override public void saveAccount() { System.out.println("保存了账户"); } }
基于 XML 的配置（入门案例）
第一步：拷贝必备的 jar 包到工程的 lib 目录中
在类的根路径下创建一个任意名称的 xml 文件（不能是中
文）给配置文件导入约束：
/spring-framework-5.0.2.RELEASE/docs/spring-framework-reference/html5/core.html
让 spring 管理资源，在配置文件中配置 service 和 dao
Spring 基于 XML 的 IOC 细节
BeanFactory 和 ApplicationContext 的区别
BeanFactory 才是 Spring 容器中的顶层接口。 ApplicationContext 是它的子接口。 BeanFactory 和 ApplicationContext 的区别： 创建对象的时间点不一样。 ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。 BeanFactory：什么使用什么时候创建对象ApplicationContext 接口的实现类
ClassPathXmlApplicationContext： 它是从类的根路径下加载配置文件 推荐使用这种 FileSystemXmlApplicationContext： 它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。 AnnotationConfigApplicationContext: 当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。IOC 中 bean 标签和管理对象细节
bean 标签
作用：
用于配置对象让 spring 来创建的。
默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。属性：
- id： 给对象在容器中提供一个唯一标识。用于获取对象。
- class： 指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
- scope： 指定对象的作用范围。
- singleton :默认值，单例的.
- prototype :多例的.
- request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
- session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
- global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.
- init-method： 指定类中的初始化方法名称。
- destroy-method： 指定类中销毁方法名称。
bean 的作用范围和生命周期
单例对象： scope="singleton"
一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期：
- 对象出生：当应用加载，创建容器时，对象就被创建了。
- 对象活着：只要容器在，对象一直活着。
- 对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
多例对象： scope="prototype"
- 每次访问对象时，都会重新创建对象实例。
- 生命周期：
- 对象出生：当使用对象时，创建新的对象实例。
- 对象活着：只要对象在使用中，就一直活着。
- 对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。
实例化 Bean 的三种方式
使用默认无参构造函数
spring 管理静态工厂-使用静态工厂的方法创建对象
/** * 模拟一个静态工厂，创建业务层实现类 */ public class StaticFactory { public static IAccountService createAccountService(){ return new AccountServiceImpl(); } }spring 管理实例工厂-使用实例工厂的方法创建对象
/** * 模拟一个实例工厂，创建业务层实现类 * 此工厂创建对象，必须现有工厂实例对象，再调用方法 */ public class InstanceFactory { public IAccountService createAccountService(){ return new AccountServiceImpl(); } }
spring 的依赖注入
依赖注入的概念
依赖注入： Dependency Injection。 它是 spring 框架核心 ioc 的具体实现。
我们的程序在编写时， 通过控制反转， 把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。
ioc 解耦只是降低他们的依赖关系，但不会消除。 例如：我们的业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系， 在使用 spring 之后， 就让 spring 来维护了。
简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。
构造函数注入
就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入。具体代码如下：
set 方法注入
在类中提供需要注入成员的 set 方法。具体代码如下：
使用 p 名称空间注入数据（本质还是调用 set 方法）
此种方式是通过在 xml 中导入 p 名称空间，使用
p:propertyName来注入数据，它的本质仍然是调用类中的set 方法实现注入功能。配置文件代码：
注入集合属性
就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。我们这里介绍注入数组， List,Set,Map,Properties。具体代码如下：
AAA BBB CCC AAA BBB CCC AAA BBB CCC aaa bbb
基于注解的 IOC 配置
步骤
- jar包
- 使用 @Component 注解配置管理的资源
- 创建 spring 的 xml 配置文件并开启对注解的支持
常用注解
用于创建对象的
相当于
@Component
作用：
把资源让 spring 来管理。相当于在 xml 中配置一个 bean。属性：
value：指定 bean 的 id。如果不指定 value 属性，默认 bean 的 id 是当前类的类名。首字母小写。
@Controller @Service @Repository
- 他们三个注解都是针对一个的衍生注解，他们的作用及属性都是一模一样的。
- 他们只不过是提供了更加明确的语义化。
- @Controller： 一般用于表现层的注解。
- @Service： 一般用于业务层的注解。
- @Repository： 一般用于持久层的注解。
- 细节：如果注解中有且只有一个属性要赋值时，且名称是 value， value 在赋值是可以不写。
用于注入数据的
相当于：
@Autowired
- 作用：
- 自动按照类型注入。当使用注解注入属性时， set 方法可以省略。它只能注入其他 bean 类型。当有多个类型匹配时，使用要注入的对象变量名称作为 bean 的 id，在 spring 容器查找，找到了也可以注入成功。找不到就报错。
- 作用：
@Qualifier
- 作用：
- 在自动按照类型注入的基础之上，再按照 Bean 的 id 注入。它在给字段注入时不能独立使用，必须和@Autowire 一起使用；但是给方法参数注入时，可以独立使用。
- 属性：
- value：指定 bean 的 id。
- 作用：
@Resource
- 作用：
- 直接按照 Bean 的 id 注入。它也只能注入其他 bean 类型。
- 属性：
- name：指定 bean 的 id。
- 作用：
@Value
- 作用：
- 注入基本数据类型和 String 类型数据的
- 属性：
- value：用于指定值
- 作用：
用于改变作用范围的
相当于：
@Scope
- 作用：
- 指定 bean 的作用范围。
- 属性：
- value：指定范围的值。
- 取值： singleton prototype request session globalsession
- value：指定范围的值。
- 作用：
和生命周期相关的：
相当于：
@PostConstruct
作用：用于指定初始化方法
@PreDestroy
作用：用于指定销毁方法。
关于 Spring 注解和 XML 的选择问题
- 注解的优势：
- 配置简单，维护方便（我们找到类，就相当于找到了对应的配置）。
- XML 的优势：
- 修改时，不用改源码。不涉及重新编译和部署。
- Spring 管理 Bean 方式的比较
- Bean 定义
- XML：
- 注解：
- @Component
- 衍生类@Repository @Service @Controller
- XML：
- Bean 名称
- XML：通过 id 或 name 指定
- 注解：@Component("person")
- Bean 注入
- XML：
- 注解：
- @Autowired 按类型注入
- @Qualifier按名称注入
- XML：
- 生命过程、Bean作用范围
- XML：
- init-method
- destroy-method
- 范围scope属性
- 注解：
- @PostConstruct 初始化
- @PreDestroy 销毁
- Scope 设置作用范围
- XML：
- 适合场景
- XML：Bean 来自第三方
- 注解：Bean 的实现类由用户自己开发
- Bean 定义
- 注解的优势：
spring 管理对象细节
基于注解的 spring IoC 配置中， bean 对象的特点和基于 XML 配置是一模一样的。
spring 的纯注解配置
待解决的问题
之所以现在离不开 xml 配置文件，是因为有一句很关键的配置：
如果他要也能用注解配置，那么我们就离脱离 xml 文件又进了一步。
另外，数据源和 JdbcTemplate 的配置也需要靠注解来实现。
新注解说明
@Configuration
- 作用：
- 用于指定当前类是一个 spring 配置类， 当创建容器时会从该类上加载注解。 获取容器时需要使用AnnotationApplicationContext(有@Configuration 注解的类.class)。
- 属性：
- value:用于指定配置类的字节码
示例代码：
@Configuration public class SpringConfiguration { }说明：把配置文件用类来代替了，继续使用 @ComponentScan 配置创建容器时要扫描的包
- 作用：
@ComponentScan
- 作用：
- 用于指定 spring 在初始化容器时要扫描的包。 作用和在 spring 的 xml 配置文件中的：
- 用于指定 spring 在初始化容器时要扫描的包。 作用和在 spring 的 xml 配置文件中的：
- 属性：
- basePackages：用于指定要扫描的包。和该注解中的 value 属性作用一样。
示例代码：
@Configuration @ComponentScan("com.xuexi") public class SpringConfiguration { }说明：配置好了要扫描的包，继续使用 @Bean 配置数据源和 JdbcTemplate 对象
- 作用：
@Bean
- 作用：
- 该注解只能写在方法上，表明使用此方法创建一个对象，并且放入 spring 容器。
- 属性：
- name：给当前@Bean 注解方法创建的对象指定一个名称(即 bean 的 id）。
示例代码：
public class JdbcConfig { /** * 创建一个数据源，并存入 spring 容器中 * @return */ @Bean(name="dataSource") public DataSource createDataSource() { try { ComboPooledDataSource ds = new ComboPooledDataSource(); ds.setUser("root"); ds.setPassword("mysql"); ds.setDriverClass("com.mysql.jdbc.Driver"); ds.setJdbcUrl("jdbc:mysql:///db_spring"); return ds; } catch (Exception e) { throw new RuntimeException(e); } } /** * 创建一个 DBAssit，并且也存入 spring 容器中 * @param dataSource * @return */ @Bean(name="dbAssit") public DBAssit createDBAssit(DataSource dataSource) { return new DBAssit(dataSource); } }说明：此时可以删除 bean.xml 了。继续使用 @PropertySource 配置创建数据源
- 作用：
- @PropertySource
- 作用：
- 用于加载.properties 文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到properties 配置文件中，就可以使用此注解指定 properties 配置文件的位置。
- 属性：
- value[]：用于指定 properties 文件位置。如果是在类路径下，需要写上 classpath:
示例代码：
public class JdbcConfig { @Value("${jdbc.driver}") private String driver; @Value("${jdbc.url}") private String url; @Value("${jdbc.username}") private String username; @Value("${jdbc.password}") private String password; /** * 创建一个数据源，并存入 spring 容器中 * @return */ @Bean(name="dataSource") public DataSource createDataSource() { try { ComboPooledDataSource ds = new ComboPooledDataSource(); ds.setDriverClass(driver); ds.setJdbcUrl(url); ds.setUser(username); ds.setPassword(password); return ds; } catch (Exception e) { throw new RuntimeException(e); } } } jdbc.properties 文件： jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/db_spring jdbc.username=root jdbc.password=mysql说明：使用 @Import 建立两个配置类的关系
- 作用：
@Import
- 作用：
- 用于导入其他配置类，在引入其他配置类时，可以不用再写@Configuration 注解。 当然，写上也没问题。
- 属性：
- value[]：用于指定其他配置类的字节码。
示例代码：
@Configuration @ComponentScan(basePackages = "com.xuexi.spring") @Import({ JdbcConfig.class}) public class SpringConfiguration { } @Configuration @PropertySource("classpath:jdbc.properties") public class JdbcConfig{ }
- 作用：
通过注解获取容器：
ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
Spring 整合 Junit
测试类中的问题和解决思路
问题
在测试类中，每个测试方法都有以下两行代码：
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); IAccountService as = ac.getBean("accountService",IAccountService.class);这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉。
解决思路
针对上述问题，需要的是程序能自动创建容器。一旦程序能自动创建 spring 容器，就无须手动创建了，问题也就解决了。junit 暴露了一个注解，可以替换掉它的运行器。这时，需要依靠 spring 框架，因为它提供了一个运行器，可以读取配置文件（或注解）来创建容器。只需要告诉它配置文件在哪就行了。
配置步骤
拷贝整合 junit 的必备 jar 包到 lib 目录
此处需要注意的是，导入 jar 包时，需要导入一个 spring 中 aop 的 jar 包。
使用@RunWith 注解替换原有运行器
@RunWith(SpringJUnit4ClassRunner.class) public class AccountServiceTest { }使用@ContextConfiguration 指定 spring 配置文件的位置
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations= {"classpath:bean.xml"}) public class AccountServiceTest { } 说明： @ContextConfiguration 注解： locations 属性： 用于指定配置文件的位置。如果是类路径下，需要用 classpath:表明 classes 属性： 用于指定注解的类。当不使用 xml 配置时，需要用此属性指定注解类的位置。使用@Autowired 给测试类中的变量注入数据
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations= {"classpath:bean.xml"}) public class AccountServiceTest { @Autowired private IAccountService as ; }
为什么不把测试类配到 xml 中
- 当在 xml 中配置了一个 bean， spring 加载配置文件创建容器时，就会创建对象。
- 测试类只是在测试功能时使用，而在项目中它并不参与程序逻辑，也不会解决需求上的问题，所以创建完了，并没有使用。那么存在容器中就会造成资源的浪费。
所以，基于以上两点，不应该把测试配置到 xml 文件中
AOP 的相关概念
概述
AOP： 全称是 Aspect Oriented Programming 即： 面向切面编程。
简单的说它就是把程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。
AOP 的作用及优势
- 作用：
- 在程序运行期间，不修改源码对已有方法进行增强。
- 优势：
- 减少重复代码
- 提高开发效率
- 维护方便
- 作用：
AOP 的实现方式
使用动态代理技术
AOP 的具体应用
问题
事务被自动控制了。换言之，使用了 connection 对象的 setAutoCommit(true)
- 此方式控制事务，如果每次都执行一条 sql 语句，没有问题，但是如果业务方法一次要执行多条 sql 语句，这种方式就无法实现功能了。
代码示例
业务层接口
/** * 转账 * @param sourceName * @param targetName * @param money */ void transfer(String sourceName,String targetName,Float money);业务层实现类：
@Override public void transfer(String sourceName, String targetName, Float money) { //根据名称查询两个账户信息 Account source = accountDao.findByName(sourceName); Account target = accountDao.findByName(targetName); //转出账户减钱，转入账户加钱 source.setMoney(source.getMoney()-money); target.setMoney(target.getMoney()+money); //更新两个账户 accountDao.update(source); int i=1/0; //模拟转账异常 accountDao.update(target); }
解决
让业务层来控制事务的提交和回滚。
- 改造后的业务层实现类：
- 注：此处没有使用 spring 的 IoC.
代码示例：
@Override public void saveAccount(Account account) { try { //开启事务 TransactionManager.beginTransaction(); accountDao.save(account); //提交事务 TransactionManager.commit(); } catch (Exception e) { //回滚事务 TransactionManager.rollback(); e.printStackTrace(); }finally { //释放资源 TransactionManager.release(); } }
- 改造后的业务层实现类：
新的问题
业务层方法变得臃肿了，里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了。
如果此时提交，回滚，释放资源中任何一个方法名变更，都需要修改业务层的代码，况且这还只是一个业务层实现类，而实际的项目中这种业务层实现类可能有十几个甚至几十个。
动态代理
动态代理的特点
- 字节码随用随创建，随用随加载。
- 它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。
- 装饰者模式就是静态代理的一种体现。
动态代理常用的两种方式
- 基于接口的动态代理
- 提供者： JDK 官方的 Proxy 类。
- 要求：被代理类最少实现一个接口。
- 基于子类的动态代理
- 提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
- 要求：被代理类不能用 final 修饰的类（最终类）。
- 基于接口的动态代理
- 使用 JDK 官方的 Proxy 类创建代理对象
使用 CGLib 的 Enhancer 类创建代理对象
解决方法
public class BeanFactory { /** * 创建账户业务层实现类的代理对象 * @return */ public static IAccountService getAccountService() { //1.定义被代理对象 final IAccountService accountService = new AccountServiceImpl(); //2.创建代理对象 IAccountService proxyAccountService = (IAccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(), accountService.getClass().getInterfaces(),new InvocationHandler() { /** * 执行被代理对象的任何方法，都会经过该方法。 * 此处添加事务控制 */ @Override public Object invoke(Object proxy, Method method,Object[] args) throws Throwable { Object rtValue = null; try { //开启事务 TransactionManager.beginTransaction(); //执行业务层方法 rtValue = method.invoke(accountService, args); //提交事务 TransactionManager.commit(); }catch(Exception e) { //回滚事务 TransactionManager.rollback(); e.printStackTrace(); }finally { //释放资源 TransactionManager.release(); } return rtValue; } }); return proxyAccountService; } }当我们改造完成之后，业务层用于控制事务的重复代码就都可以删掉了
Spring 中的 AOP
Spring 中 AOP 的细节
AOP 相关术语
- Joinpoint(连接点):
- 所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
- Pointcut(切入点):
- 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
- Advice(通知/增强):
- 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
- 通知的类型： 前置通知,后置通知,异常通知,最终通知,环绕通知。
- Introduction(引介):
- 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
- Target(目标对象):
- 代理的目标对象。
- Weaving(织入):
- 是指把增强应用到目标对象来创建新的代理对象的过程。
- spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
- Proxy（代理） :
- 一个类被 AOP 织入增强后，就产生一个结果代理类。
- Aspect(切面):
- 是切入点和通知（引介）的结合。
- Joinpoint(连接点):
学习 spring 中的 AOP 要明确的事
- 开发阶段（我们做的）
- 编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。
- 把公用代码抽取出来，制作成通知。（开发阶段最后再做）： AOP 编程人员来做。
- 在配置文件中，声明切入点与通知间的关系，即切面。： AOP 编程人员来做。
- 运行阶段（ Spring 框架完成的）
- Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。
- 开发阶段（我们做的）
关于代理的选择
在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。
基于 XML 的 AOP 配置
环境搭建
- jar包
创建 spring 的配置文件并导入约束
此处要导入 aop 的约束
配置 spring 的 ioc
抽取公共代码制作成通知
public class TransactionManager { //定义一个 DBAssit private DBAssit dbAssit ; public void setDbAssit(DBAssit dbAssit) { this.dbAssit = dbAssit; } //开启事务 public void beginTransaction() { try { dbAssit.getCurrentConnection().setAutoCommit(false); } catch (SQLException e) { e.printStackTrace(); } } //提交事务 public void commit() { try { dbAssit.getCurrentConnection().commit(); } catch (SQLException e) { e.printStackTrace(); } } //回滚事务 public void rollback() { try { dbAssit.getCurrentConnection().rollback(); } catch (SQLException e) { e.printStackTrace(); } } //释放资源 public void release() { try { dbAssit.releaseConnection(); } catch (Exception e) { e.printStackTrace(); } } }
配置步骤
把通知类用 bean 标签配置起来
使用 aop:config 声明 aop 配置
aop:config: 作用： 用于声明开始 aop 的配置使用 aop:aspect 配置切面
aop:aspect: 作用： 用于配置切面。 属性： id： 给切面提供一个唯一标识。 ref： 引用配置好的通知类 bean 的 id。使用 aop:pointcut 配置切入点表达式
aop:pointcut： 作用： 用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。 属性： expression：用于定义切入点表达式。 id： 用于给切入点表达式提供一个唯一标识使用 aop:xxx 配置对应的通知类型
aop:before 作用： 用于配置前置通知。 指定增强的方法在切入点方法之前执行 属性： method:用于指定通知类中的增强方法名称 ponitcut-ref：用于指定切入点的表达式的引用 poinitcut：用于指定切入点表达式 执行时间点： 切入点方法执行之前执行
切入点表达式说明
execution:匹配方法的执行(常用) execution(表达式) 表达式语法： execution([修饰符] 返回值类型 包名.类名.方法名(参数)) 写法说明： 全匹配方式： public void com.xuexi.service.impl.AccountServiceImpl.saveAccount(com.xuexi.domain.Account) 访问修饰符可以省略 void com.xuexi.service.impl.AccountServiceImpl.saveAccount(com.xuexi.domain.Account) 返回值可以使用*号，表示任意返回值 com.xuexi.service.impl.AccountServiceImpl.saveAccount(com.xuexi.domain.Account) 包名可以使用*号，表示任意包，但是有几级包，需要写几个 *.*.*.*.AccountServiceImpl.saveAccount(com.xuexi.domain.Account) 使用..来表示当前包，及其子包 com..AccountServiceImpl.saveAccount(com.xuexi.domain.Account) 类名可以使用*号，表示任意类 com..*.saveAccount(com.xuexi.domain.Account) 方法名可以使用*号，表示任意方法 com..*.*( com.xuexi.domain.Account) 参数列表可以使用*，表示参数可以是任意数据类型，但是必须有参数 com..*.*(*) 参数列表可以使用..表示有无参数均可，有参数可以是任意类型 com..*.*(..) 全通配方式： *..*.*(..)环绕通知
配置方式:
- aop:around：
- 作用：
- 用于配置环绕通知
- 属性：
- method：指定通知中方法的名称。
- pointct：定义切入点表达式
- pointcut-ref：指定切入点表达式的引用
- 说明：
- 它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。
- 注意：
- 通常情况下，环绕通知都是独立使用的
- 作用：
代码示例
/** * 环绕通知 * @param pjp * spring 框架为我们提供了一个接口： ProceedingJoinPoint，它可以作为环绕通知的方法参数。 * 在环绕通知执行时， spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。 * @return */ public Object transactionAround(ProceedingJoinPoint pjp) { //定义返回值 Object rtValue = null; try { //获取方法执行所需的参数 Object[] args = pjp.getArgs(); //前置通知：开启事务 beginTransaction(); //执行方法 rtValue = pjp.proceed(args); //后置通知：提交事务 commit(); }catch(Throwable e) { //异常通知：回滚事务 rollback(); e.printStackTrace(); }finally { //最终通知：释放资源 release(); } return rtValue; }
基于注解的 AOP 配置
环境搭建
- jar包
在配置文件中导入 context 的名称空间
把资源使用注解配置
@Service("accountService") public class AccountServiceImpl implements IAccountService { @Autowired private IAccountDao accountDao; } @Repository("accountDao") public class AccountDaoImpl implements IAccountDao { @Autowired private DBAssit dbAssit; }在配置文件中指定 spring 要扫描的包
配置步骤
把通知类也使用注解配置
@Component("txManager") public class TransactionManager { //定义一个 DBAssit @Autowired private DBAssit dbAssit ; }在通知类上使用@Aspect 注解声明为切面
作用： 把当前类声明为切面类。 @Component("txManager") @Aspect//表明当前类是一个切面类 public class TransactionManager { //定义一个 DBAssit @Autowired private DBAssit dbAssit ; }在增强的方法上使用注解配置通知
@Before 作用： 把当前方法看成是前置通知。 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用。 //开启事务 @Before("execution(* com.xuexi.service.impl.*.*(..))") public void beginTransaction() { try { dbAssit.getCurrentConnection().setAutoCommit(false); } catch (SQLException e) { e.printStackTrace(); } } @AfterReturning 作用： 把当前方法看成是后置通知。 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用 //提交事务 @AfterReturning("execution(* com.xuexi.service.impl.*.*(..))") public void commit() { try { dbAssit.getCurrentConnection().commit(); } catch (SQLException e) { e.printStackTrace(); } } @AfterThrowing 作用： 把当前方法看成是异常通知。 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用 //回滚事务 @AfterThrowing("execution(* com.xuexi.service.impl.*.*(..))") public void rollback() { try { dbAssit.getCurrentConnection().rollback(); } catch (SQLException e) { e.printStackTrace(); } } @After 作用： 把当前方法看成是最终通知。 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用 //释放资源 @After("execution(* com.xuexi.service.impl.*.*(..))") public void release() { try { dbAssit.releaseConnection(); } catch (Exception e) { e.printStackTrace(); } }在 spring 配置文件中开启 spring 对注解 AOP 的支持
环绕通知注解配置
@Around 作用： 把当前方法看成是环绕通知。 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用。 /** * 环绕通知 * @param pjp * @return */ @Around("execution(* com.xuexi.service.impl.*.*(..))") public Object transactionAround(ProceedingJoinPoint pjp) { //定义返回值 Object rtValue = null; try { //获取方法执行所需的参数 Object[] args = pjp.getArgs(); //前置通知：开启事务 beginTransaction(); //执行方法 rtValue = pjp.proceed(args); //后置通知：提交事务 commit(); }catch(Throwable e) { //异常通知：回滚事务 rollback(); e.printStackTrace(); }finally { //最终通知：释放资源 release(); } return rtValue; }切入点表达式注解
@Pointcut 作用： 指定切入点表达式 属性： value：指定表达式的内容 @Pointcut("execution(* com.xuexi.service.impl.*.*(..))") private void pt1() {} 引用方式： /** * 环绕通知 * @param pjp * @return */ @Around("pt1()")//注意：千万别忘了写括号 public Object transactionAround(ProceedingJoinPoint pjp) { //定义返回值 Object rtValue = null; try { //获取方法执行所需的参数 Object[] args = pjp.getArgs(); //前置通知：开启事务 beginTransaction(); //执行方法 rtValue = pjp.proceed(args); //后置通知：提交事务 commit(); }catch(Throwable e) { //异常通知：回滚事务 rollback(); e.printStackTrace(); }finally { //最终通知：释放资源 release(); } return rtValue; }不使用 XML 的配置方式
@Configuration @ComponentScan(basePackages="com.xuexi") @EnableAspectJAutoProxy public class SpringConfiguration { }
Spring 中的 JdbcTemplate
概述
它是 spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装。 spring 框架为我们提供了很多的操作模板类。
- 操作关系型数据的：
- JdbcTemplate
- HibernateTemplate
- 操作 nosql 数据库的：
- RedisTemplate
- 操作消息队列的：
- JmsTemplate
JdbcTemplate 对象的创建
参考源码
public JdbcTemplate() {
}
public JdbcTemplate(DataSource dataSource) {
setDataSource(dataSource);
afterPropertiesSet();
}
public JdbcTemplate(DataSource dataSource, boolean lazyInit) {
setDataSource(dataSource);
setLazyInit(lazyInit);
afterPropertiesSet();
}除了默认构造函数之外，都需要提供一个数据源。既然有set方法，依据依赖注入，可以在配置文件中配置这些对象。
spring 中配置数据源
- jar包
编写 spring 的配置文件
- 配置数据源
- 配置 C3P0 数据源
- 导入jar包
在 spring 的配置文件中配置
- 配置 DBCP 数据源
- 导入jar包
在 spring 的配置文件中配置
配置 spring 内置数据源
spring 框 架 也 提 供 了 一 个 内 置 数 据 源 ， 我 们 也 可 以 使 用 spring 的 内 置 数 据 源 ， 它 就 在
spring-jdbc-5.0.2.REEASE.jar 包中：
- 配置 C3P0 数据源
将数据库连接的信息配置到属性文件中
【定义属性文件】 jdbc.driverClass=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql:///db_spring jdbc.username=root jdbc.password=mysql 【引入外部的属性文件】 一种方式:
JdbcTemplate 的增删改查操作
前期准备
创建数据库： create database db_spring; use db_spring; 创建表： create table account( id int primary key auto_increment, name varchar(40), money float )character set utf8 collate utf8_general_ci;在 spring 配置文件中配置 JdbcTemplate
基本使用
//1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 jt.execute("insert into account(name,money)values('eee',500)");保存操作
//1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //保存 jt.update("insert into account(name,money)values(?,?)","fff",5000);更新操作
//1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //修改 jt.update("update account set money = money-? where id = ?",300,6);删除操作
//1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //删除 jt.update("delete from account where id = ?",6);查询所有操作
public class JdbcTemplateDemo3 { public static void main(String[] args) { //1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //查询所有 Listaccounts = jt.query("select * from account where money > ? ", new AccountRowMapper(), 500); for(Account o : accounts){ System.out.println(o); } } } public class AccountRowMapper implements RowMapper { @Override public Account mapRow(ResultSet rs, int rowNum) throws SQLException { Account account = new Account(); account.setId(rs.getInt("id")); account.setName(rs.getString("name")); account.setMoney(rs.getFloat("money")); return account; } } 查询一个操作
使用 RowMapper 的方式：常用的方式
public class JdbcTemplateDemo3 { public static void main(String[] args) { //1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //查询一个 Listas = jt.query("select * from account where id = ? ", new AccountRowMapper(), 55); System.out.println(as.isEmpty()?"没有结果":as.get(0)); } } 使用 ResultSetExtractor 的方式:不常用的方式
public class JdbcTemplateDemo3 { public static void main(String[] args) { //1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //查询一个 Account account = jt.query("select * from account where id = ?", new AccountResultSetExtractor(),3); System.out.println(account); } }查询返回一行一列操作
//1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //查询返回一行一列：使用聚合函数，在不使用 group by 字句时，都是返回一行一列。最长用的 就是分页中获取总记录条数 Integer total = jt.queryForObject("select count(*) from account where money > ? ",Integer.class,500); System.out.println(total);
在 dao 中使用 JdbcTemplate
第一种方式：在 dao 中定义 JdbcTemplate
public class AccountDaoImpl implements IAccountDao { private JdbcTemplate jdbcTemplate; …… }配置文件
当 dao 有很多时，每个 dao 都有一些重复性的代码。下面就是重复代码：
private JdbcTemplate jdbcTemplate; public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { this.jdbcTemplate = jdbcTemplate; }第二种方式：让 dao 继承 JdbcDaoSupport
JdbcDaoSupport 是 spring 框架为我们提供的一个类，该类中定义了一个 JdbcTemplate 对象，可以直接获取使用，但是要想创建该对象，需要为其提供一个数据源：具体源码如下：
public abstract class JdbcDaoSupport extends DaoSupport { //定义对象 private JdbcTemplate jdbcTemplate; //set 方法注入数据源，判断是否注入了，注入了就创建 JdbcTemplate public final void setDataSource(DataSource dataSource) { if (this.jdbcTemplate == null || dataSource != this.jdbcTemplate.getDataSource()) { //如果提供了数据源就创建 JdbcTemplate this.jdbcTemplate = createJdbcTemplate(dataSource); initTemplateConfig(); } } //使用数据源创建 JdcbTemplate protected JdbcTemplate createJdbcTemplate(DataSource dataSource) { return new JdbcTemplate(dataSource); } //当然，我们也可以通过注入 JdbcTemplate 对象 public final void setJdbcTemplate(JdbcTemplate jdbcTemplate) { this.jdbcTemplate = jdbcTemplate; initTemplateConfig(); } //使用 getJdbcTmeplate 方法获取操作模板对象 public final JdbcTemplate getJdbcTemplate() { return this.jdbcTemplate; } } /** * 账户的持久层实现类 * 此版本 dao，只需要给它的父类注入一个数据源 */ @Override public Account findAccountById(Integer id) { //getJdbcTemplate()方法是从父类上继承下来的。 Listlist = getJdbcTemplate().query("select * from account where id = ? ",new AccountRowMapper(),id); return list.isEmpty()?null:list.get(0); } 配置文件：
两种的区别
- 第一种在 Dao 类中定义 JdbcTemplate 的方式，适用于所有配置方式（ xml 和注解都可以）。
- 第二种让 Dao 继承 JdbcDaoSupport 的方式，只能用于基于 XML 的方式，注解用不了。
Spring 中的事务控制
Spring 事务控制我们要明确的
- JavaEE 体系进行分层开发，事务处理位于业务层， Spring 提供了分层设计业务层的事务处理解决方案。
- spring 框架为我们提供了一组事务控制的接口。具体在后面的第二小节介绍。这组接口是在spring-tx-5.0.2.RELEASE.jar 中。
- spring 的事务控制都是基于 AOP 的，它既可以使用编程的方式实现，也可以使用配置的方式实现。 我们学习的重点是使用配置的方式实现。
Spring 中事务控制的 API 介绍
PlatformTransactionManager
此接口是 spring 的事务管理器，它里面提供了我们常用的操作事务的方法，如下：
- 获取事务状态信息
- TransactionStatus getTransaction(TransactionDefinition definition)
- 提交事务
- void commit(TransactionStatus status)
- 回滚事务
- void rollback(TransactionStatus status)
- 获取事务状态信息
TransactionDefinition
它是事务的定义信息对象，有如下方法：
- 获取事务对象名称
- String getName()
- 获取事务隔离级
- int getIsolationLevel()
- 获取事务传播行为
- int getPropagationBehavior()
- 获取事务超时时间
- int getTimeout()
- 获取事务是否只读
- boolean isReadOnly()
事务的传播行为
- REQUIRED:如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）
- SUPPORTS:支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）
- MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常
- REQUERS_NEW:新建事务，如果当前在事务中，把当前事务挂起。
- NOT_SUPPORTED:以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
- NEVER:以非事务方式运行，如果当前存在事务，抛出异常
- NESTED:如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 REQUIRED 类似的操作。
超时时间
- 默认值是-1，没有超时限制。如果有，以秒为单位进行设置
是否是只读事务
- 建议查询时设置为只读。
- 获取事务对象名称
TransactionStatus
此接口提供的是事务具体的运行状态，方法介绍如下：
- 刷新事务
- void flush()
- 获取是否存在存储点
- boolean hasSavepoint()
- 获取事务是否完成
- boolean isComppleted()
- 获取事务是否为新的事务
- boolean isNewTransaction()
- 获取事务是否回滚
- boolean isRollbackOnly()
基于 XML 的声明式事务控制（配置方式）
- 环境搭建
- jar包
创建 spring 的配置文件并导入约束
此处需要导入 aop 和 tx 两个名称空间
- 准备数据库表和实体类
- 编写业务层接口和实现类
- 编写 Dao 接口和实现类
在配置文件中配置业务层和持久层
配置步骤
配置事务管理器
配置事务的通知引用事务管理器
配置事务的属性
配置 AOP 切入点表达式
配置切入点表达式和事务通知的对应关系
基于注解的配置方式
- 环境搭建
- jar包
创建 spring 的配置文件导入约束并配置扫描的包
- 创建数据库表和实体类
创建业务层接口和实现类并使用注解让 spring 管理
/** * 账户的业务层实现类 */ @Service("accountService") public class AccountServiceImpl implements IAccountService { @Autowired private IAccountDao accountDao; //其余代码和基于 XML 的配置相同创建 Dao 接口和实现类并使用注解让 spring 管理
/** * 账户的持久层实现类 */ @Repository("accountDao") public class AccountDaoImpl implements IAccountDao { @Autowired private JdbcTemplate jdbcTemplate; //其余代码和基于 XML 的配置相同 }
配置步骤
配置事务管理器并注入数据源
在业务层使用 @Transactional 注解
@Service("accountService") @Transactional(readOnly=true,propagation=Propagation.SUPPORTS) public class AccountServiceImpl implements IAccountService { @Autowired private IAccountDao accountDao; @Override public Account findAccountById(Integer id) { return accountDao.findAccountById(id); } @Override @Transactional(readOnly=false,propagation=Propagation.REQUIRED) public void transfer(String sourceName, String targeName, Float money) { //1.根据名称查询两个账户 Account source = accountDao.findAccountByName(sourceName); Account target = accountDao.findAccountByName(targeName); //2.修改两个账户的金额 source.setMoney(source.getMoney()-money);//转出账户减钱 target.setMoney(target.getMoney()+money);//转入账户加钱 //3.更新两个账户 accountDao.updateAccount(source); //int i=1/0; accountDao.updateAccount(target); } }- 该注解的属性和 xml 中的属性含义一致。该注解可以出现在接口上，类上和方法上。
- 出现接口上，表示该接口的所有实现类都有事务支持。
- 出现在类上，表示类中所有方法有事务支持
- 出现在方法上，表示方法有事务支持。
- 以上三个位置的优先级：方法>类>接口
在配置文件中开启 spring 对注解事务的支持
不使用 xml 的配置方式
@Configuration @EnableTransactionManagement public class SpringTxConfiguration { //里面配置数据源，配置 JdbcTemplate,配置事务管理器。在之前的步骤已经写过了。 }