企业网站维护合同,中瑞网络网站建设流程,深圳网络科技公司排名,网站宣传海报文章目录 1. IOC/DI注解开发2. IOC/DI注解开发管理第三方bean3. Spring整合4. AOP简介5. AOP入门案例6. AOP工作流程7. AOP配置管理8. AOP事务管理 1. IOC/DI注解开发
注解开发定义bean用的是2.5版提供的注解#xff0c;纯注解开发用的是3.0版提供的注解 pom.xml添加依赖
纯注解开发用的是3.0版提供的注解 pom.xml添加依赖
dependenciesdependencygroupIdorg.springframework/groupIdartifactIdspring-context/artifactIdversion5.2.10.RELEASE/version/dependency
/dependencies注解开发定义bean 第一步Dao上添加注解 在BookDaoImpl类上添加Component注解 Component(bookDao)
public class BookDaoImpl implements BookDao {public void save() {System.out.println(book dao save ... );}
}注意:Component注解不可以添加在接口上因为接口是无法创建对象的 XML与注解配置的对应关系: 第二步配置Spring的注解包扫描 ?xml version1.0 encodingUTF-8?
beans xmlnshttp://www.springframework.org/schema/beansxmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexsi:schemaLocationhttp://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdcontext:component-scan base-packagecom.itheima/
/beans说明: component-scan component:组件,Spring将管理的bean视作自己的一个组件scan:扫描 base-package指定Spring框架扫描的包路径它会扫描指定包及其子包中的所有类上的注解。 包路径越多[如:com.itheima.dao.impl]扫描的范围越小速度越快包路径越少[如:com.itheima],扫描的范围越大速度越慢一般扫描到项目的组织名称即Maven的groupId下[如:com.itheima]即可 其他 1Component注解如果不起名称会有一个默认值就是当前类名首字母小写所以也可以按照名称获取 2对于Component注解还衍生出了其他三个注解Controller、Service、Repository这三个注解和Component注解的作用是一样的方便我们后期在编写类的时候能很好的区分出这个类是属于表现层、业务层还是数据层的类。 纯注解开发模式 步骤1:创建配置类 创建一个配置类SpringConfigConfiguration//在配置类上添加Configuration注解将其标识为一个配置类,替换applicationContext.xml
ComponentScan(com.itheima)//在配置类上添加包扫描注解ComponentScan替换context:component-scan base-package/
public class SpringConfig {
}//ComponentScan注解用于设定扫描路径此注解只能添加一次多个数据请用数组格式
//ComponentScan({com.itheima.service,com.itheima.dao})步骤4:创建运行类并执行public class AppForAnnotation {public static void main(String[] args) {ApplicationContext ctx new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao (BookDao) ctx.getBean(bookDao);System.out.println(bookDao);BookService bookService ctx.getBean(BookService.class);System.out.println(bookService);}
}注解开发bean作用范围与生命周期管理 Bean的作用范围 要想将BookDaoImpl变成非单例只需要在其类上添加scope注解 Repository
//Scope设置bean的作用范围
Scope(prototype)
public class BookDaoImpl implements BookDao {public void save() {System.out.println(book dao save ...);}
}Bean的生命周期 (1)在BookDaoImpl中添加两个方法init和destroy,方法名可以任意 (2)只需要在对应的方法上添加PostConstruct和PreDestroy注解即可 Repository
public class BookDaoImpl implements BookDao {public void save() {System.out.println(book dao save ...);}PostConstruct //在构造方法之后执行替换 init-methodpublic void init() {System.out.println(init ...);}PreDestroy //在销毁方法之前执行,替换 destroy-methodpublic void destroy() {System.out.println(destroy ...);}
}(3)要想看到两个方法执行需要注意的是destroy只有在容器关闭的时候才会执行所以需要修改App的类 public class App {public static void main(String[] args) {AnnotationConfigApplicationContext ctx new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao1 ctx.getBean(BookDao.class);BookDao bookDao2 ctx.getBean(BookDao.class);System.out.println(bookDao1);System.out.println(bookDao2);ctx.close(); //关闭容器}
}注意:PostConstruct和PreDestroy注解如果找不到需要导入下面的jar包 dependencygroupIdjavax.annotation/groupIdartifactIdjavax.annotation-api/artifactIdversion1.3.2/version
/dependency找不到的原因是从JDK9以后jdk中的javax.annotation包被移除了这两个注解刚好就在这个包中 注解开发依赖注入 注解实现按照类型注入 在属性上添加Autowired注解 Service
public class BookServiceImpl implements BookService {Autowiredprivate BookDao bookDao;// public void setBookDao(BookDao bookDao) {
// this.bookDao bookDao;
// }public void save() {System.out.println(book service save ...);bookDao.save();}
}注意: Autowired可以写在属性上也可也写在setter方法上最简单的处理方式是写在属性上并将setter方法删除掉自动装配基于反射设计创建对象并通过暴力反射为私有属性进行设值, 所以此处无需提供setter方法Autowired默认按照类型自动装配如果IOC容器中同类的Bean找到多个就按照变量名和Bean的名称匹配 注解实现按照名称注入 Service
public class BookServiceImpl implements BookService {AutowiredQualifier(bookDao1)private BookDao bookDao;public void save() {System.out.println(book service save ...);bookDao.save();}
}1Qualifier注解后的值就是需要注入的bean的名称 2Qualifier不能独立使用必须和Autowired一起使用 简单数据类型注入 使用Value注解将值写入注解的参数中 Repository(bookDao)
public class BookDaoImpl implements BookDao {Value(itheima)private String name;public void save() {System.out.println(book dao save ... name);}
}注解读取properties配置文件 Value一般会被用在从properties配置文件中读取内容进行使用 1jdbc.properties nameitheima8882在配置类上添加PropertySource注解 Configuration
ComponentScan(com.itheima)
PropertySource(jdbc.properties)
public class SpringConfig {
}3使用Value读取配置文件中的内容 Repository(bookDao)
public class BookDaoImpl implements BookDao {Value(${name})private String name;public void save() {System.out.println(book dao save ... name);}
}如果读取的properties配置文件有多个可以使用PropertySource的属性来指定多个PropertySource({jdbc.properties,xxx.properties})PropertySource注解属性中不支持使用通配符*,运行会报错PropertySource({*.properties})PropertySource注解属性中可以把classpath:加上,代表从当前项目的根路径找文件PropertySource({classpath:jdbc.properties})2. IOC/DI注解开发管理第三方bean 不引用外部配置类 1在配置类中添加一个方法在方法上添加Bean注解 Configuration
public class SpringConfig {Beanpublic DataSource dataSource(){DruidDataSource ds new DruidDataSource();ds.setDriverClassName(com.mysql.jdbc.Driver);ds.setUrl(jdbc:mysql://localhost:3306/spring_db);ds.setUsername(root);ds.setPassword(root);return ds;}
}
//不能使用DataSource ds new DruidDataSource()
//因为DataSource接口中没有对应的setter方法来设置属性
//如果有多个bean要被Spring管理直接在配置类中多些几个方法方法上添加Bean注解即可。2从IOC容器中获取对象并打印 public class App {public static void main(String[] args) {AnnotationConfigApplicationContext ctx new AnnotationConfigApplicationContext(SpringConfig.class);DataSource dataSource ctx.getBean(DataSource.class);System.out.println(dataSource);}
}引入外部配置类 对于数据源的bean,我们新建一个JdbcConfig配置类并把数据源配置到该类下。 public class JdbcConfig {Beanpublic DataSource dataSource(){DruidDataSource ds new DruidDataSource();ds.setDriverClassName(com.mysql.jdbc.Driver);ds.setUrl(jdbc:mysql://localhost:3306/spring_db);ds.setUsername(root);ds.setPassword(root);return ds;}
}配置类如何能被Spring配置类加载到并创建DataSource对象在IOC容器中? 方式一使用包扫描引入 步骤1:在Spring的配置类上添加包扫描 Configuration
ComponentScan(com.itheima.config)
public class SpringConfig {}步骤2:在JdbcConfig上添加配置注解 JdbcConfig类要放入到com.itheima.config包下需要被Spring的配置类扫描到即可 Configuration
public class JdbcConfig {Beanpublic DataSource dataSource(){DruidDataSource ds new DruidDataSource();ds.setDriverClassName(com.mysql.jdbc.Driver);ds.setUrl(jdbc:mysql://localhost:3306/spring_db);ds.setUsername(root);ds.setPassword(root);return ds;}
}方式二使用Import引入 这种方案可以不用加Configuration注解但是必须在Spring配置类上使用Import注解手动引入需要加载的配置类 在Spring配置类中引入 Configuration
//ComponentScan(com.itheima.config)
Import({JdbcConfig.class})
public class SpringConfig {}注意: 扫描注解可以移除Import参数需要的是一个数组可以引入多个配置类。Import注解在配置类中只能写一次 注解开发实现为第三方bean注入资源 简单数据类型 类中提供四个属性使用Value注解引入值public class JdbcConfig {Value(com.mysql.jdbc.Driver)private String driver;Value(jdbc:mysql://localhost:3306/spring_db)private String url;Value(root)private String userName;Value(password)private String password;Beanpublic DataSource dataSource(){DruidDataSource ds new DruidDataSource();ds.setDriverClassName(driver);ds.setUrl(url);ds.setUsername(userName);ds.setPassword(password);return ds;}
}现在的数据库连接四要素还是写在代码中需要做的是将这些内容提取到jdbc.properties配置文件运用注解读取properties配置文件的知识引用数据类型 1在SpringConfig中扫描BookDao 扫描的目的是让Spring能管理到BookDao,也就是说要让IOC容器中有一个bookDao对象Configuration
ComponentScan(com.itheima.dao)
Import({JdbcConfig.class})
public class SpringConfig {
}2在JdbcConfig类的方法上添加参数Bean
public DataSource dataSource(BookDao bookDao){System.out.println(bookDao);DruidDataSource ds new DruidDataSource();ds.setDriverClassName(driver);ds.setUrl(url);ds.setUsername(userName);ds.setPassword(password);return ds;
}引用类型注入只需要为bean定义方法设置形参即可容器会根据类型自动装配对象
对比XML配置和注解的开发实现
3. Spring整合 Spring整合Mybatis 步骤1:项目中导入整合需要的jar包 dependency!--Spring操作数据库需要该jar包--groupIdorg.springframework/groupIdartifactIdspring-jdbc/artifactIdversion5.2.10.RELEASE/version
/dependency
dependency!--Spring与Mybatis整合的jar包这个jar包mybatis在前面是Mybatis提供的--groupIdorg.mybatis/groupIdartifactIdmybatis-spring/artifactIdversion1.3.0/version
/dependency步骤2:创建Spring的主配置类 //配置类注解
Configuration
//包扫描主要扫描的是项目中的AccountServiceImpl类
ComponentScan(com.itheima)
public class SpringConfig {
}步骤3:创建数据源的配置类 在配置类中完成数据源的创建 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;Beanpublic DataSource dataSource(){DruidDataSource ds new DruidDataSource();ds.setDriverClassName(driver);ds.setUrl(url);ds.setUsername(userName);ds.setPassword(password);return ds;}
}步骤4:主配置类中读properties并引入数据源配置类 Configuration
ComponentScan(com.itheima)
PropertySource(classpath:jdbc.properties)
Import(JdbcConfig.class)
public class SpringConfig {
} 步骤5:创建Mybatis配置类并配置SqlSessionFactory public class MybatisConfig {//定义beanSqlSessionFactoryBean用于产生SqlSessionFactory对象Beanpublic SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){SqlSessionFactoryBean ssfb new SqlSessionFactoryBean();//设置模型类的别名扫描ssfb.setTypeAliasesPackage(com.itheima.domain);//设置数据源ssfb.setDataSource(dataSource);return ssfb;}//定义bean返回MapperScannerConfigurer对象Beanpublic MapperScannerConfigurer mapperScannerConfigurer(){MapperScannerConfigurer msc new MapperScannerConfigurer();msc.setBasePackage(com.itheima.dao);return msc;}
}说明: 使用SqlSessionFactoryBean封装SqlSessionFactory需要的环境信息 SqlSessionFactoryBean是前面我们讲解FactoryBean的一个子类在该类中将SqlSessionFactory的创建进行了封装简化对象的创建我们只需要将其需要的内容设置即可。方法中有一个参数为dataSource,当前Spring容器中已经创建了Druid数据源类型刚好是DataSource类型此时在初始化SqlSessionFactoryBean这个对象的时候发现需要使用DataSource对象而容器中刚好有这么一个对象就自动加载了DruidDataSource对象。 使用MapperScannerConfigurer加载Dao接口创建代理对象保存到IOC容器中 这个MapperScannerConfigurer对象也是MyBatis提供的专用于整合的jar包中的类用来处理原始配置文件中的mappers相关配置加载数据层的Mapper接口类MapperScannerConfigurer有一个核心属性basePackage就是用来设置所扫描的包路径 步骤6:主配置类中引入Mybatis配置类 Configuration
ComponentScan(com.itheima)
PropertySource(classpath:jdbc.properties)
Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}步骤7:编写运行类 在运行类中从IOC容器中获取Service对象调用方法获取结果 public class App2 {public static void main(String[] args) {ApplicationContext ctx new AnnotationConfigApplicationContext(SpringConfig.class);AccountService accountService ctx.getBean(AccountService.class);Account ac accountService.findById(1);System.out.println(ac);}
} 步骤8:运行程序 支持Spring与Mybatis的整合就已经完成了其中主要用到的两个类分别是: SqlSessionFactoryBeanMapperScannerConfigurer Spring整合Junit 步骤1:引入依赖 dependencygroupIdjunit/groupIdartifactIdjunit/artifactIdversion4.12/versionscopetest/scope
/dependencydependencygroupIdorg.springframework/groupIdartifactIdspring-test/artifactIdversion5.2.10.RELEASE/version
/dependency步骤2:编写测试类 //设置类运行器
RunWith(SpringJUnit4ClassRunner.class)
//设置Spring环境对应的配置类
ContextConfiguration(classes {SpringConfiguration.class}) //加载配置类
//ContextConfiguration(locations{classpath:applicationContext.xml})//加载配置文件
public class AccountServiceTest {//支持自动装配注入beanAutowiredprivate AccountService accountService;Testpublic void testFindById(){System.out.println(accountService.findById(1));}Testpublic void testFindAll(){System.out.println(accountService.findAll());}
}注意: 单元测试如果测试的是注解配置类则使用ContextConfiguration(classes 配置类.class)单元测试如果测试的是配置文件则使用ContextConfiguration(locations{配置文件名,...})
4. AOP简介
1AOP(Aspect Oriented Programming)面向切面编程一种编程范式指导开发者如何组织程序结构 2AOP作用在不惊动原始设计的基础上为其进行功能增强无入侵式/无侵入式 AOP核心概念 (1)前面一直在强调Spring的AOP是对一个类的方法在不进行任何修改的前提下实现增强。对于上面的案例中BookServiceImpl中有save,update,delete和select方法,这些方法我们给起了一个名字叫连接点 (2)在BookServiceImpl的四个方法中update和delete只有打印没有计算万次执行消耗时间但是在运行的时候已经有该功能那也就是说update和delete方法都已经被增强所以对于需要增强的方法我们给起了一个名字叫切入点 (3)执行BookServiceImpl的update和delete方法的时候都被添加了一个计算万次执行消耗时间的功能将这个功能抽取到一个方法中换句话说就是存放共性功能的方法我们给起了个名字叫通知 (4)通知是要增强的内容会有多个切入点是需要被增强的方法也会有多个那哪个切入点需要添加哪个通知就需要提前将它们之间的关系描述清楚那么对于通知和切入点之间的关系描述我们给起了个名字叫切面 (5)通知是一个方法方法不能独立存在需要被写在一个类中这个类我们也给起了个名字叫通知类 连接点(JoinPoint)程序执行过程中的任意位置粒度为执行方法、抛出异常、设置变量等 在SpringAOP中理解为方法的执行 切入点(Pointcut):匹配连接点的式子 在SpringAOP中一个切入点可以描述一个具体方法也可也匹配多个方法 一个具体的方法:如com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法匹配多个方法:所有的save方法所有的get开头的方法所有以Dao结尾的接口中的任意方法所有带有一个参数的方法 连接点范围要比切入点范围大是切入点的方法也一定是连接点但是是连接点的方法就不一定要被增强所以可能不是切入点。 通知(Advice):在切入点处执行的操作也就是共性功能 在SpringAOP中功能最终以方法的形式呈现 通知类定义通知的类切面(Aspect):描述通知与切入点的对应关系
5. AOP入门案例
需求为:使用SpringAOP的注解方式完成在方法执行的前打印出当前系统时间 步骤1:添加依赖 pom.xml dependencygroupIdorg.aspectj/groupIdartifactIdaspectjweaver/artifactIdversion1.9.4/version
/dependency因为spring-context中已经导入了spring-aop,所以不需要再单独导入spring-aop 步骤2:定义通知类和通知 通知就是将共性功能抽取出来后形成的方法共性功能指的就是当前系统时间的打印 public class MyAdvice {public void method(){System.out.println(System.currentTimeMillis());}
}类名和方法名没有要求可以任意 步骤3:定义切入点 切入点定义依托一个不具有实际意义的方法进行即无参数、无返回值、方法体无实际逻辑 public class MyAdvice {Pointcut(execution(void com.itheima.dao.BookDao.update())) //设置切入点方法private void pt(){}public void method(){System.out.println(System.currentTimeMillis());}
}步骤4:制作切面 切面是用来描述通知和切入点之间的关系 public class MyAdvice {Pointcut(execution(void com.itheima.dao.BookDao.update()))private void pt(){}//设置当前通知方法与切入点之间的绑定关系当前通知方法在原始切入点方法前运行Before(pt())public void method(){System.out.println(System.currentTimeMillis());}
}步骤5:将通知类配给容器并标识其为切面类 Component
Aspect //设置当前类为AOP切面类
public class MyAdvice {Pointcut(execution(void com.itheima.dao.BookDao.update()))private void pt(){}Before(pt())public void method(){System.out.println(System.currentTimeMillis());}
}步骤6:开启注解格式AOP功能 Configuration
ComponentScan(com.itheima)
EnableAspectJAutoProxy //开启注解格式AOP功能
public class SpringConfig {
}6. AOP工作流程 流程1:Spring容器启动 容器启动就需要去加载bean,哪些类需要被加载呢?需要被增强的类如:BookServiceImpl通知类如:MyAdvice注意此时bean对象还没有创建成功 流程2:读取所有切面配置中的切入点 上面这个例子中有两个切入点的配置但是第一个ptx()并没有被使用所以不会被读取 流程3:初始化bean 匹配失败创建原始对象 匹配失败说明不需要增强直接调用原始对象的方法即可。 匹配成功创建原始对象目标对象的代理对象 匹配成功说明需要对其进行增强对哪个类做增强这个类对应的对象就叫做目标对象因为要对目标对象进行功能增强而采用的技术是动态代理所以会为其创建一个代理对象最终运行的是代理对象的方法在该方法中会对原始方法进行功能增强 流程4:获取bean执行方法 获取的bean是原始对象时调用方法并执行完成操作获取的bean是代理对象时根据代理对象的运行模式运行原始方法与增强的内容完成操作 AOP核心概念 目标对象(Target)原始功能去掉共性功能对应的类产生的对象这种对象是无法直接完成最终工作的代理(Proxy)目标对象无法直接完成工作需要对其进行功能回填通过原始对象的代理对象实现 SpringAOP的本质或者可以说底层实现是通过代理模式
7. AOP配置管理 AOP切入点表达式 切入点表达式:要进行增强的方法的描述方式 描述方式一接口执行com.itheima.dao包下的BookDao接口中的无参数update方法 execution(void com.itheima.dao.BookDao.update())描述方式二实现类执行com.itheima.dao.impl包下的BookDaoImpl类中的无参数update方法 execution(void com.itheima.dao.impl.BookDaoImpl.update())语法格式动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名 对于这个格式我们不需要硬记通过一个例子理解它: execution(public User com.itheima.service.UserService.findById(int))execution动作关键字描述切入点的行为动作例如execution表示执行到指定切入点public:访问修饰符,还可以是publicprivate等可以省略User返回值写返回值类型com.itheima.service包名多级包使用点连接UserService:类/接口名称findById方法名int:参数直接写参数的类型多个类型用逗号隔开异常名方法定义中抛出指定异常可以省略 通配符 作用简化配置 *:单个独立的任意符号可以独立出现也可以作为前缀或者后缀的匹配符出现 executionpublic * com.itheima.*.UserService.find*(*))匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法 ..多个连续的任意符号可以独立出现常用于简化包名与参数的书写 executionpublic User com..UserService.findById(..))匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法 专用于匹配子类类型 execution(* *..*Service.*(..))这个使用率较低描述子类的做JavaEE开发继承机会就一次使用都很慎重所以很少用它。*Service表示所有以Service结尾的接口的子类。 书写技巧 所有代码按照标准规范开发否则以下技巧全部失效描述切入点通常描述接口而不描述实现类,如果描述到实现类就出现紧耦合了访问控制修饰符针对接口开发均采用public描述可省略访问控制修饰符描述返回值类型对于增删改类使用精准类型加速匹配对于查询类使用*通配快速描述包名书写尽量不使用..匹配效率过低常用*做单个包描述匹配或精准匹配接口名/类名书写名称与模块相关的采用*匹配例如UserService书写成*Service绑定业务层接口名方法名书写以动词进行精准匹配名词采用匹配例如getById书写成getBy,selectAll书写成selectAll参数规则较为复杂根据业务方法灵活调整通常不使用异常作为匹配规则 AOP通知类型 5种通知类型 前置通知 追加功能到方法执行前 Component
Aspect
public class MyAdvice {Pointcut(execution(void com.itheima.dao.BookDao.update()))private void pt(){}Before(pt())//此处也可以写成 Before(MyAdvice.pt()),不建议public void before() {System.out.println(before advice ...);}
}后置通知 追加功能到方法执行后,不管方法执行的过程中有没有抛出异常都会执行 Component
Aspect
public class MyAdvice {Pointcut(execution(void com.itheima.dao.BookDao.update()))private void pt(){}After(pt())public void after() {System.out.println(after advice ...);}
}环绕通知(重点) 可以追加功能到方法执行的前后 Component
Aspect
public class MyAdvice {Pointcut(execution(void com.itheima.dao.BookDao.update()))private void pt(){}Pointcut(execution(int com.itheima.dao.BookDao.select()))private void pt2(){}Around(pt2())public Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable {System.out.println(around before advice ...);//表示对原始操作的调用Object ret pjp.proceed();System.out.println(around after advice ...);return ret;}
}注意事项 环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用进而实现原始方法调用前后同时添加通知通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行对原始方法的调用可以不接收返回值通知方法设置成void即可如果接收返回值最好设定为Object类型原始方法的返回值如果是void类型通知方法的返回值类型可以设置成void,也可以设置成Object由于无法预知原始方法运行后是否会抛出异常因此环绕通知方法必须要处理Throwable异常 返回后通知(了解) 追加功能到方法执行后只有方法正常执行结束后才进行 Component
Aspect
public class MyAdvice {Pointcut(execution(void com.itheima.dao.BookDao.update()))private void pt(){}Pointcut(execution(int com.itheima.dao.BookDao.select()))private void pt2(){}AfterReturning(pt2())public void afterReturning() {System.out.println(afterReturning advice ...);}
}抛出异常后通知(了解) 追加功能到方法抛出异常后只有方法执行出异常才进行 Component
Aspect
public class MyAdvice {Pointcut(execution(void com.itheima.dao.BookDao.update()))private void pt(){}Pointcut(execution(int com.itheima.dao.BookDao.select()))private void pt2(){}AfterReturning(pt2())public void afterThrowing() {System.out.println(afterThrowing advice ...);}
}业务层接口执行效率-案例 需求:任意业务层接口执行均可显示其执行效率执行时长 步骤1:开启SpringAOP的注解功能 在Spring的主配置文件SpringConfig类中添加注解 EnableAspectJAutoProxy步骤2:创建AOP的通知类 该类要被Spring管理需要添加Component要标识该类是一个AOP的切面类需要添加Aspect配置切入点表达式需要添加一个方法并添加Pointcut Component
Aspect
public class ProjectAdvice {//配置业务层的所有方法Pointcut(execution(* com.itheima.service.*Service.*(..)))private void servicePt(){}public void runSpeed(){}
}步骤3:添加环绕通知 在runSpeed()方法上添加Around Component
Aspect
public class ProjectAdvice {//配置业务层的所有方法Pointcut(execution(* com.itheima.service.*Service.*(..)))private void servicePt(){}//Around(ProjectAdvice.servicePt()) 可以简写为下面的方式Around(servicePt())public Object runSpeed(ProceedingJoinPoint pjp){Object ret pjp.proceed();return ret;}
}步骤4:完成核心业务记录万次执行的时间 Component
Aspect
public class ProjectAdvice {//配置业务层的所有方法Pointcut(execution(* com.itheima.service.*Service.*(..)))private void servicePt(){}//Around(ProjectAdvice.servicePt()) 可以简写为下面的方式Around(servicePt())public void runSpeed(ProceedingJoinPoint pjp){long start System.currentTimeMillis();for (int i 0; i 10000; i) {pjp.proceed();}long end System.currentTimeMillis();System.out.println(业务层接口万次执行时间: (end-start)ms);}
}步骤5:程序优化 Component
Aspect
public class ProjectAdvice {//配置业务层的所有方法Pointcut(execution(* com.itheima.service.*Service.*(..)))private void servicePt(){}//Around(ProjectAdvice.servicePt()) 可以简写为下面的方式Around(servicePt())public void runSpeed(ProceedingJoinPoint pjp){//获取执行签名信息Signature signature pjp.getSignature();//通过签名获取执行操作名称(接口名)String className signature.getDeclaringTypeName();//通过签名获取执行操作名称(方法名)String methodName signature.getName();long start System.currentTimeMillis();for (int i 0; i 10000; i) {pjp.proceed();}long end System.currentTimeMillis();System.out.println(万次执行 className.methodName---- (end-start) ms);}
}AOP通知获取数据 获取切入点方法的参数所有的通知类型都可以获取参数 JoinPoint适用于前置、后置、返回后、抛出异常后通知ProceedingJoinPoint适用于环绕通知 获取切入点方法返回值前置和抛出异常后通知是没有返回值后置通知可有可无所以不做研究 返回后通知环绕通知 获取切入点方法运行异常信息前置和返回后通知是不会有后置通知可有可无所以不做研究 抛出异常后通知环绕通知 获取参数 非环绕通知获取方式 在方法上添加JoinPoint,通过JoinPoint来获取参数 Component
Aspect
public class MyAdvice {Pointcut(execution(* com.itheima.dao.BookDao.findName(..)))private void pt(){}Before(pt())public void before(JoinPoint jp) Object[] args jp.getArgs();System.out.println(Arrays.toString(args));System.out.println(before advice ... );}//...其他的略
}环绕通知获取方式 环绕通知使用的是ProceedingJoinPoint因为ProceedingJoinPoint是JoinPoint类的子类所以对于ProceedingJoinPoint类中应该也会有对应的getArgs()方法 Component
Aspect
public class MyAdvice {Pointcut(execution(* com.itheima.dao.BookDao.findName(..)))private void pt(){}Around(pt())public Object around(ProceedingJoinPoint pjp)throws Throwable {Object[] args pjp.getArgs();System.out.println(Arrays.toString(args));Object ret pjp.proceed();return ret;}//其他的略
}pjp.proceed()方法是有两个构造方法分别是: 调用无参数的proceed当原始方法有参数会在调用的过程中自动传入参数 所以调用这两个方法的任意一个都可以完成功能 但是当需要修改原始方法的参数时就只能采用带有参数的方法,如下: Component
Aspect
public class MyAdvice {Pointcut(execution(* com.itheima.dao.BookDao.findName(..)))private void pt(){}Around(pt())public Object around(ProceedingJoinPoint pjp) throws Throwable{Object[] args pjp.getArgs();System.out.println(Arrays.toString(args));args[0] 666;Object ret pjp.proceed(args);return ret;}//其他的略
}有了这个特性后我们就可以在环绕通知中对原始方法的参数进行拦截过滤避免由于参数的问题导致程序无法正确运行保证代码的健壮性。 获取返回值 环绕通知获取返回值 Component
Aspect
public class MyAdvice {Pointcut(execution(* com.itheima.dao.BookDao.findName(..)))private void pt(){}Around(pt())public Object around(ProceedingJoinPoint pjp) throws Throwable{Object[] args pjp.getArgs();System.out.println(Arrays.toString(args));args[0] 666;Object ret pjp.proceed(args);return ret;}//其他的略
}上述代码中ret就是方法的返回值我们是可以直接获取不但可以获取如果需要还可以进行修改。 返回后通知获取返回值 Component
Aspect
public class MyAdvice {Pointcut(execution(* com.itheima.dao.BookDao.findName(..)))private void pt(){}AfterReturning(value pt(),returning ret)public void afterReturning(Object ret) {System.out.println(afterReturning advice ...ret);}//其他的略
}注意: (1)参数名的问题 (2)afterReturning方法参数类型的问题 参数类型可以写成String但是为了能匹配更多的参数类型建议写成Object类型 (3)afterReturning方法参数的顺序问题 获取异常 环绕通知获取异常 只需要将异常捕获就可以获取到原始方法的异常信息 Component
Aspect
public class MyAdvice {Pointcut(execution(* com.itheima.dao.BookDao.findName(..)))private void pt(){}Around(pt())public Object around(ProceedingJoinPoint pjp){Object[] args pjp.getArgs();System.out.println(Arrays.toString(args));args[0] 666;Object ret null;try{ret pjp.proceed(args);}catch(Throwable t){t.printStackTrace();}return ret;}//其他的略
}抛出异常后通知获取异常 Component
Aspect
public class MyAdvice {Pointcut(execution(* com.itheima.dao.BookDao.findName(..)))private void pt(){}AfterThrowing(value pt(),throwing t)public void afterThrowing(Throwable t) {System.out.println(afterThrowing advice ...t);}//其他的略
}密码数据兼容处理-案例 需求是使用AOP将参数进行统一处理不管输入的密码root前后包含多少个空格最终控制台打印的都是true 步骤1:开启SpringAOP的注解功能 Configuration
ComponentScan(com.itheima)
EnableAspectJAutoProxy
public class SpringConfig {
}步骤2:编写通知类 Component
Aspect
public class DataAdvice {Pointcut(execution(boolean com.itheima.service.*Service.*(*,*)))private void servicePt(){}}步骤3:添加环绕通知 Component
Aspect
public class DataAdvice {Pointcut(execution(boolean com.itheima.service.*Service.*(*,*)))private void servicePt(){}Around(DataAdvice.servicePt())// Around(servicePt())这两种写法都对public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {Object ret pjp.proceed();return ret;}}步骤4:完成核心业务处理参数中的空格 Component
Aspect
public class DataAdvice {Pointcut(execution(boolean com.itheima.service.*Service.*(*,*)))private void servicePt(){}Around(DataAdvice.servicePt())// Around(servicePt())这两种写法都对public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {//获取原始方法的参数Object[] args pjp.getArgs();for (int i 0; i args.length; i) {//判断参数是不是字符串if(args[i].getClass().equals(String.class)){args[i] args[i].toString().trim();}}//将修改后的参数传入到原始方法的执行中Object ret pjp.proceed(args);return ret;}}8. AOP事务管理 Spring事务简介 事务作用在数据层保障一系列的数据库操作同成功同失败 Spring事务作用在数据层或**业务层**保障一系列的数据库操作同成功同失败 Spring为了管理事务提供了一个平台事务管理器PlatformTransactionManager PlatformTransactionManager只是一个接口Spring还为其提供了一个具体的实现: 从名称上可以看出我们只需要给它一个DataSource对象它就可以帮你去在业务层管理事务。其内部采用的是JDBC的事务。所以说如果你持久层采用的是JDBC相关的技术就可以采用这个事务管理器来管理你的事务。而Mybatis内部采用的就是JDBC的事务所以后期我们Spring整合Mybatis就采用的这个DataSourceTransactionManager事务管理器 案例转账 需求: 实现任意两个账户间转账操作 Spring事务管理具体的实现步骤为: 步骤1:在需要被事务管理的方法上添加注解 public interface AccountService {/*** 转账操作* param out 传出方* param in 转入方* param money 金额*///配置当前接口方法具有事务public void transfer(String out,String in ,Double money) ;
}Service
public class AccountServiceImpl implements AccountService {Autowiredprivate AccountDao accountDao;Transactionalpublic void transfer(String out,String in ,Double money) {accountDao.outMoney(out,money);int i 1/0;accountDao.inMoney(in,money);}
}注意: Transactional可以写在接口类上、接口方法上、实现类上和实现类方法上 写在接口类上该接口的所有实现类的所有方法都会有事务写在接口方法上该接口的所有实现类的该方法都会有事务写在实现类上该类中的所有方法都会有事务写在实现类方法上该方法上有事务建议写在实现类或实现类的方法上 步骤2:在JdbcConfig类中配置事务管理器 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;Beanpublic DataSource dataSource(){DruidDataSource ds new DruidDataSource();ds.setDriverClassName(driver);ds.setUrl(url);ds.setUsername(userName);ds.setPassword(password);return ds;}//配置事务管理器mybatis使用的是jdbc事务Beanpublic PlatformTransactionManager transactionManager(DataSource dataSource){DataSourceTransactionManager transactionManager new DataSourceTransactionManager();transactionManager.setDataSource(dataSource);return transactionManager;}
}**注意**事务管理器要根据使用技术进行选择Mybatis框架使用的是JDBC事务可以直接使用DataSourceTransactionManager 步骤3开启事务注解 在SpringConfig的配置类中开启 Configuration
ComponentScan(com.itheima)
PropertySource(classpath:jdbc.properties)
Import({JdbcConfig.class,MybatisConfig.class
//开启注解式事务驱动
EnableTransactionManagement
public class SpringConfig {
}Spring事务角色 开启Spring的事务管理后 transfer上添加了Transactional注解在该方法上就会有一个事务TAccountDao的outMoney方法的事务T1加入到transfer的事务T中AccountDao的inMoney方法的事务T2加入到transfer的事务T中这样就保证他们在同一个事务中当业务层中出现异常整个事务就会回滚保证数据的准确性。
事务管理员发起事务方在Spring中通常指代业务层开启事务的方法事务协调员加入事务方在Spring中通常指代数据层方法也可以是业务层方法
Spring事务属性 事务配置 上面这些属性都可以在Transactional注解的参数上进行设置。 readOnlytrue只读事务false读写事务增删改要设为false,查询设为true。 timeout:设置超时时间单位秒在多长时间之内事务没有提交成功就自动回滚-1表示不设置超时时间。 rollbackFor:当出现指定异常进行事务回滚 Spring的事务只会对Error异常和RuntimeException异常及其子类进行事务回顾其他的异常类型是不会回滚的 例如可以使用rollbackFor属性来设置出现IOException异常不回滚 Service
public class AccountServiceImpl implements AccountService {Autowiredprivate AccountDao accountDao;Transactional(rollbackFor {IOException.class})public void transfer(String out,String in ,Double money) throws IOException{accountDao.outMoney(out,money);//int i 1/0; //这个异常事务会回滚if(true){throw new IOException(); //这个异常事务就不会回滚}accountDao.inMoney(in,money);}}noRollbackFor:当出现指定异常不进行事务回滚 rollbackForClassName等同于rollbackFor,只不过属性为异常的类全名字符串 noRollbackForClassName等同于noRollbackFor只不过属性为异常的类全名字符串 isolation设置事务的隔离级别 DEFAULT :默认隔离级别, 会采用数据库的隔离级别READ_UNCOMMITTED : 读未提交READ_COMMITTED : 读已提交REPEATABLE_READ : 重复读取SERIALIZABLE: 串行化 转账业务追加日志案例 需求无论转账操作是否成功均进行转账操作的日志留痕 对于上述案例的分析: log方法、inMoney方法和outMoney方法都属于增删改分别有事务T1,T2,T3transfer因为加了Transactional注解也开启了事务T前面我们讲过Spring事务会把T1,T2,T3都加入到事务T中所以当转账失败后所有的事务都回滚导致日志没有记录下来这和我们的需求不符这个时候我们就想能不能让log方法单独是一个事务呢? 要想解决这个问题就需要用到事务传播行为需要用到之前我们没有说的propagation属性 事务传播行为事务协调员对事务管理员所携带事务的处理态度。 1.修改logService改变事务的传播行为 Service
public class LogServiceImpl implements LogService {Autowiredprivate LogDao logDao;//propagation设置事务属性传播行为设置为当前操作需要新事务Transactional(propagation Propagation.REQUIRES_NEW)public void log(String out,String in,Double money ) {logDao.log(转账操作由out到in,金额money);}
}运行后就能实现我们想要的结果不管转账是否成功都会记录日志 2.事务传播行为的可选值
