实验三 Spring基于XML和注解的AOP配置

合集下载

SpringAop注解实现

SpringAop注解实现⽬录Spring-aop-理论知识 Spring-Aop-注解实现项⽬结构图具体步骤：1、创建maven 项⽬导⼊依赖创建好项⽬结构2、写⼀个接⼝及其实现类3、切⾯类4、application.xml ⽂件测试总结Spring-aop-理论知识 Spring-Aop-注解实现项⽬结构图具体步骤：1、创建maven 项⽬导⼊依赖创建好项⽬结构<dependencies><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.18</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.4</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>5.3.4</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>5.3.4</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-expression</artifactId><version>5.3.4</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.3.4</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.6</version></dependency></dependencies>2、写⼀个接⼝及其实现类/*** @version 1.0* @author： crush* @date： 2021-03-05 10:26*/public interface TestDao {public void delete();}/*** @version 1.0* @author： crush* @date： 2021-03-05 10:27*/@Servicepublic class TestDaoImpl implements TestDao {public void delete() {System.out.println("正在执⾏的⽅法-->删除");}}3、切⾯类/*** @version 1.0* @author： crush* @date： 2021-03-10 18:04*/@Aspect@Componentpublic class MyAspectAnnotation {@Pointcut("execution(* com.dao.*.*(..))")private void myPointCut(){}/*** 前置通知使⽤JoinPoint 接⼝作为参数获得⽬标对象的信息* @Before("myPointCut()") ==* <aop:after method="after" pointcut-ref="myPointCut"/>**/@Before("myPointCut()")public void before(JoinPoint jp){System.out.print("前置通知：模拟权限控制");System.out.println("⽬标对象："+jp.getTarget()+",被增强的⽅法："+jp.getSignature().getName()); }@AfterReturning("myPointCut()")public void afterReturning(JoinPoint jp){System.out.print("后置返回通知："+"模拟删除临时⽂件");System.out.println(",被增强的⽅法"+jp.getSignature().getName());}@Around("myPointCut()")public Object around(ProceedingJoinPoint pjp) throws Throwable {System.out.println("环绕开始：执⾏⽬标⽅法前，模拟开启事务");Object obj = pjp.proceed();System.out.println("环绕结束：执⾏⽬标⽅法后，模拟关闭事务");return obj;}@AfterThrowing(value = "myPointCut()",throwing = "throwable")public void except(Throwable throwable){System.out.println("异常通知："+"程序执⾏异常"+throwable.getMessage());}@After("myPointCut()")public void after(){System.out.println("最终通知：释放资源");}}4、application.xml ⽂件<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd /schema/aop https:///schema/aop/spring-aop.xsd"> <context:component-scan base-package="com.dao"/><context:component-scan base-package="com.aspect"/><aop:aspectj-autoproxy proxy-target-class="true"/></beans>测试@Testpublic void Test(){ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");TestDao testDao = applicationContext.getBean("testDaoImpl", TestDaoImpl.class);testDao.delete();/*** 输出：* 环绕开始：执⾏⽬标⽅法前，模拟开启事务* 前置通知：模拟权限控制⽬标对象：com.dao.TestDaoImpl@2bef51f2,被增强的⽅法：delete* 正在执⾏的⽅法-->删除* 后置返回通知：模拟删除临时⽂件,被增强的⽅法delete* 最终通知：释放资源* 环绕结束：执⾏⽬标⽅法后，模拟关闭事务*/}总结本篇⽂章就到这⾥了，希望能给你带来帮助，也希望您能够多多关注的更多内容！。

AOP

完成一个验证用户权限的实例：
可以使用cglib-nodep.jar创建代理对象，
使用Spring提供的类进行操作：
Spring框架下进行AOP编程：
Spring提供了两种切面使用方式，实际工作中我们可以选用其中一种：
1、基于XML配置方式进行AOP开发
2、基于注解方式进行AOP开发
一、基于注解方式进行AOP开发：
首先定义一个被拦截的目标对象：
当在一个配置文件中进行多个目标对象时，将对所有的目标对象进行织入
当配置多个切面时，将形成一个栈，进行织入
表达式：execution(* com.spring.aop.StudentDAO.*(..))的意义
如果拦截返回类型非void方法的可以使用：execution(!void com.spring.aop.StudentDAO.*(..))。

spring的xml以及纯注解综合案例

spring的xml以及纯注解综合案例⼀、Spring的XML的环境搭建案例实现数据库CRUD2.Bean.xml的配置<bean id="accountService" class="com.li.service.impl.AccountServiceImpl"><property name="accountDao" ref="accountDao"></property></bean><bean id="accountDao" class="com.li.dao.impl.AccountDaoImpl"><property name="runner" ref="runner"></property></bean><bean id="runner" class="mons.dbutils.QueryRunner" scope="prototype"><constructor-arg name="ds" ref="dataSource"></constructor-arg></bean><bean id="dataSource" class="boPooledDataSource"><property name="driverClass" value="com.mysql.jdbc.Driver"></property><property name="jdbcUrl" value="jdbc:mysql:///spring"></property><property name="user" value="root"></property><property name="password" value="123"></property></bean>⼆、注解的环境搭建案例实现数据库CRUD1.创建⼀个配置类，作⽤与Bean.xml（spring 的配置⽂件）的作⽤⼀致；spring的新注解：@Configuration: 指定当前类为配置类（即创建Bean.xml⽂件）@ComponentScan: ⽤于通过注解指定spring在创建容器时要扫描的包属性：value：它和basePackages的作⽤⼀样，都是⽤于创建容器时所扫描的包此注解就等同于xml的配置:<context:component-scan base-package="com.li"></context:component-scan>@Bean: ⽤于把当前的返回值作为bean对存⼊spring的IOC容器中属性：name:指定bean的id,如果不指定，为当前⽅法的名称；细节：当我们使⽤注解配置⽅法时，如果⽅法有参数，spring框架回去容器中查找有没有可⽤的bean对象，查找的⽅法和Autowired注解的作⽤⼀样的，⾃动按照类型注⼊@Import: 导⼊其他类属性：value:⽤于指定其他配置类的字节码当我们使⽤Import的注解后，有Import注解的类就是⽗配置类，⽽导⼊的为⼦配置类；@propertySource: ⽤于指定properties⽂件位置属性 classpath：⽤于指定⽂件名名称和路径//配置类@Configuration@ComponentScan("com.li")@Import(JdbcConfig.class)@PropertySource("classpath:jdbcConfig.properties")public class SpringConfiguration {}/*** 和spring连接数据库相关的配置类*/public class JdbcConfig {@Value("${jdbc.driver}")private String driver;@Value("${jdbc.url}")private String url;@Value("${ername}")private String username;@Value("${jdbc.password}")private String password;/*** ⽤于创建⼀个QueryRunner对象，封装jdbc连接数据库，*/@Bean("runner")@Scope("prototype")public QueryRunner creatQueryRunner(@Qualifier("ds1") DataSource dataSource){return new QueryRunner(dataSource);}/*** 创建数据源对象* @return*/@Bean("ds1")public DataSource dataSource(){try {ComboPooledDataSource ds =new ComboPooledDataSource(); //使⽤连接池创建数据源ds.setDriverClass(driver); //加载驱动ds.setJdbcUrl(url);ds.setUser(username);ds.setPassword(password);return ds;} catch (PropertyVetoException e) {throw new RuntimeException(e);}}@Bean(name="ds2")public DataSource dataSource2(){try {ComboPooledDataSource ds =new ComboPooledDataSource();ds.setDriverClass(driver);ds.setJdbcUrl("jdbc:mysql:///mbase");ds.setUser(username);ds.setPassword(password);return ds;} catch (PropertyVetoException e) {throw new RuntimeException(e);}}}2.测试类中Spring整合Junit的配置1）导⼊Spring整合Junit的jar坐标2）使⽤junit提供的注解把原有main⽅法替换，替换成spring提供的；3）告知spring运⾏器，spring和ioc创建时基于xml还是注解，并说明位置； @ContextConfiguration：属性：locations:指定xml位置，加上classpath关键字，表⽰在类路劲下 @ContextConfiguration(locations = "classpath:bean.xml")classes:指定注解类的位置：@ContextConfiguration(classes = SpringConfiguration.class) @RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes = SpringConfiguration.class)public class AccountServiceTest {@Autowiredprivate IAccountService as=null;@Testpublic void testFindAll(){//3.执⾏⽅法List<Account> accounts = as.findAllAccount();for (Account account:accounts){System.out.println(account);}}。

Spring的AOP配置

Spring的AOP配置(2011-04-01 20:38:58)转载标签：分类：SSH框架springaop配置获取参数it1.先写一个普通类：package com.spring.aop;public class Common {public void execute(String username,String password){ System.out.println("------------------普通类----------------");}}2.写一个切面类，用于合法性校验和日志添加：package com.spring.aop;public class Check {public void checkValidity(){System.out.println("------------------验证合法性----------------"); }public void addLog(JoinPoint j){System.out.println("------------------添加日志----------------");Object obj[] = j.getArgs();for(Object o :obj){System.out.println(o);}System.out.println("========checkSecurity=="+j.getSignature().getName());//这个是获得方法名}}3.配置AOP，使用XML方式：（注意红色标志的内容）<?xml version="1.0" encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="common" class="mon"/><bean id="check" class="com.spring.aop.Check"/><aop:config><aop:aspect id="myAop" ref="check"><aop:pointcut id="target" expression="execution(*mon.execute(..))"/><aop:before method="checkValidity" pointcut-ref="target"/><aop:after method="addLog" pointcut-ref="target"/></aop:aspect></aop:config>注意：execution(* com.spring.aop.*.*(..))"/这样写应该就可以了这是com.aptech.jb.epet.dao.hibimpl 包下所有的类的所有方法。

【SpringFramework】Spring入门教程（三）使用注解配置

【SpringFramework】Spring⼊门教程（三）使⽤注解配置本⽂主要介绍四个⽅⾯：(1) 注解版本IOC和DI(2) Spring纯注解(3) Spring测试(4) SpringJDBC - Spring对数据库的操作使⽤注解配置Spring⼊门说在前⾯学习基于注解的IoC配置，⼤家脑海⾥⾸先得有⼀个认知，即注解配置和xml配置要实现的功能都是⼀样的，都是要降低模块间的耦合度。

仅仅只是配置的形式不⼀样。

关于实际的开发中到底使⽤xml还是注解，每家公司有着不同的使⽤习惯。

所以这两种配置⽅式我们都需要掌握。

基于注解配置的⽅式也已经逐渐代替xml配置。

所以我们必须要掌握使⽤注解的⽅式配置Spring。

配置步骤注意：如果使⽤Eclipse需要先安装了STS插件，或者使⽤STS开发⼯具创建项⽬。

本⽂使⽤IDEA进⾏演⽰。

1.2.1. 第⼀步：拷贝必备jar包到⼯程的lib⽬录。

注意：在基于注解的配置中，我们还要多拷贝⼀个aop的jar包。

如下图：1.2.2. 第⼆步：在类的根路径下创建⼀个任意名称的xml⽂件（不能是中⽂）注意：基于注解整合时，Spring配置⽂件导⼊约束时需要多导⼊⼀个context命名空间下的约束。

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"></beans>1.2.3. 第⼆步：创建⼀个服务类创建⼀个测试的服务类，并且加⼊使⽤@Component注解，声明该类允许注⼊到Spring容器package org.cjw.service;import ponent;/*使⽤注解配置时，需要将Spring框架启动就创建对象的类表⽰为组件类表⽰组件类使⽤@Component注解*/@Componentpublic class CustomerService {public void save() {System.out.println("-保存数据-");}}1.2.4. 第四步在spring的配置⽂件加⼊扫描注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"><context:component-scan base-package="org.cjw" /></beans>1.2.5. 第五步：测试调⽤代码package org.cjw.test;import org.cjw.service.CustomerService;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class CustomerServiceTest {@Testpublic void testSave() {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");CustomerService customerService = context.getBean(CustomerService.class);customerService.save();}}--测试结果，如果可以调⽤服务⽅法，测试成功。

Spring：AOP（xml形式的环绕通知）

Spring：AOP（xml形式的环绕通知）AOP概念:AOP的作⽤以及优势AOP的相关术语基于XML的AOP配置<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/aop/schema/aop/spring-aop.xsd">View Codespring中基于XML的AOP配置步骤 1、把通知Bean也交给spring来管理 2、使⽤aop:config标签表明开始AOP的配置 3、使⽤aop:aspect标签表明配置切⾯ id属性：是给切⾯提供⼀个唯⼀标识 ref属性：是指定通知类bean的Id。

4、在aop:aspect标签的内部使⽤对应标签来配置通知的类型我们现在⽰例是让printLog⽅法在切⼊点⽅法执⾏之前之前：所以是前置通知 aop:before：表⽰配置前置通知 method属性：⽤于指定Logger类中哪个⽅法是前置通知 pointcut属性：⽤于指定切⼊点表达式，该表达式的含义指的是对业务层中哪些⽅法增强切⼊点表达式的写法：关键字：execution(表达式)表达式：访问修饰符返回值包名.包名.包名...类名.⽅法名(参数列表)标准的表达式写法：public void com.itheima.service.impl.AccountServiceImpl.saveAccount()访问修饰符可以省略void com.itheima.service.impl.AccountServiceImpl.saveAccount()返回值可以使⽤通配符，表⽰任意返回值* com.itheima.service.impl.AccountServiceImpl.saveAccount()包名可以使⽤通配符，表⽰任意包。

Springxml注入以及xml配置

Springxml注⼊以及xml配置xml 配置<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"></beans>注⼊⽅式<bean id="Addresa" class=".jieless.Addresa"/><bean id="pojo" class=".jieless.pojo" name="pojo2"><property name="name" value="我是name"/><property name="address" ref="Addresa"/><property name="books"><array><value>西游记</value><value>红楼梦</value><value>三国演义</value><value>⽔浒传</value></array></property><property name="hobby"><list><value>西游记List</value><value>红楼梦List</value><value>三国演义List</value><value>⽔浒传List</value></list></property><property name="card"><map><entry key="⾝份证" value="4564645465465456678"></entry></map></property><property name="wife"><set><value>QQ飞车</value><value>QQ炫舞</value><value>穿越⽕线</value></set></property><property name="jieW"><null/></property><property name="info"><props><prop key="driver">4564546</prop><prop key="url">hfafhafafafafaf</prop><prop key="root">root</prop><prop key="pwd">518340</prop></props></property></bean>。

SpringAOP的注解方式实现

SpringAOP的注解⽅式实现spring也⽀持注解⽅式实现AOP，相对于配置⽂件⽅式，注解配置更加的轻量级，配置、修改更加⽅便。

1.开启AOP的注解配置⽅式<aop:aspectj-autoproxy></aop:aspectj-autoproxy>2.将定制的类标志为⼀个切⾯3.配置通知，指定切⼊点规则前置通知 @Before环绕通知 @Around后置通知 @AfterReturning异常通知 @AfterThrowing最终通知 @After@Before("execution(* cn.tedu.service.*.*(..))")public void before(JoinPoint jp){Class clz = jp.getTarget().getClass();Signature signature = jp.getSignature();String name = signature.getName();System.out.println("before...["+clz+"]...["+name+"]...");}** 通过注解的配置等价于配置⽂件的配置4.重复使⽤同⼀个切⼊点表达式如果⼀个切⾯中多个通知重复使⽤同⼀个切⼊点表达式，则可以将该切⼊点表达式单独定义，后续引⽤。

注意，在当前切⾯中通过注解定义的切⼊点只在当前切⾯中起作⽤，其他切⾯看不到。

5.额外配置⼀个returning属性在后置通知的注解中，也可以额外配置⼀个returning属性，来指定⼀个参数名接受⽬标⽅法执⾏后的返回值。

6.异常通知的注解在异常通知的注解中，也可以额外配置⼀个throwing属性，来指定⼀个参数名接受⽬标⽅法抛出的异常对象。

源码<?xml version="1.0" encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.2.xsd/schema/context/schema/context/spring-context-3.2.xsd/schema/aop/schema/aop/spring-aop-3.2.xsd "><context:annotation-config></context:annotation-config><context:component-scan base-package="cn.tedu.service,cn.tedu.aop"></context:component-scan> <aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>package cn.tedu.service;public interface UserService {public String addUser(String name);public void updateUser();public void deleteUser();public void query();}package cn.tedu.service;import org.springframework.stereotype.Service;@Service("userService")public class UserServiceImple implements UserService {@Overridepublic String addUser(String name) {// int i = 10/0;System.out.println("增加⽤户。

Spring之注解实现aop（面向切面编程）

Spring之注解实现aop（⾯向切⾯编程）1:Aop(aspect object programming)⾯向切⾯编程，名词解释:1.1:功能:让关注点代码与业务逻辑代码分离1.2:关注点重复代码就叫做关注点1.3:切⾯关注点形成的类，就叫做切⾯(类)⾯向切⾯编程，就是指对很多功能都有的重复代码抽取，再在运⾏的时候往业务⽅法上动态植⼊"切⾯类代码"；1.4:切⼊点执⾏⽬标对象⽅法，动态植⼊切⾯代码可以通过切⼊点表达式，指定拦截那些类的那些⽅法，给指定的类在运⾏的时候植⼊切⾯类代码；2:注解⽅式实现aop编程2.1:开发步骤(1):先引⼊aop相关的jar⽂件spring-aop-3.2.5.RELEASE.jar【去spring3.2源码⾥⾯找】aopalliance.jar【去spring2.5源码/lib/aopalliance⽂件⾥⾯找】aspectjweaver.jar【去spring2.5源码/lib/aspectj⽂件⾥⾯找】或者【aspectj-1.8.2/lib/aspectjweaver.jar】aspectjrt.jar【去spring2.5源码/lib/aspectj⽂件⾥⾯找】或者【aspectj-1.8.2/lib/aspectjrt.jar】《注意：⽤到的spring2.5版本的jar本舰，如果⽤jd1.7版本可能会出现问题，需要升级以下aspectj组件，即使⽤aspectj-1.8.2版本中提供的jar⽂件aspectjweaver.jar和aspectjrt.jar》(2)bean.xml中引⼊aop名称空间技巧：找到⽂件spring-framework-3.2.5.RELEASE/docs/spring-framework-reference/htmlsingle 打开index.html搜索xmlns:aop然后找到下⾯红⾊三句话，分别拷贝到bean.xml中 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="/schema/beans" xmlns:xsi="/2001/XMLSchema-instance" xmlns:aop="/schema/aop" xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd /schema/aop /schema/aop/spring-aop.xsd"> 拷贝之后的bean.xml如下所⽰：1<?xml version="1.0" encoding="UTF-8"?>2<beans xmlns="/schema/beans"3 xmlns:xsi="/2001/XMLSchema-instance"4 xmlns:p="/schema/p"5 xmlns:context="/schema/context"6 xmlns:aop="/schema/aop"7 xsi:schemaLocation="8 /schema/beans9 /schema/beans/spring-beans.xsd10 /schema/context11 /schema/context/spring-context.xsd12 /schema/aop13 /schema/aop/spring-aop.xsd">1415</beans> (3):bean.xml中开启aop注解扫描，如下配置所⽰：1<?xml version="1.0" encoding="UTF-8"?>2<beans xmlns="/schema/beans"3 xmlns:xsi="/2001/XMLSchema-instance"4 xmlns:p="/schema/p"5 xmlns:context="/schema/context"6 xmlns:aop="/schema/aop"7 xsi:schemaLocation="8 /schema/beans9 /schema/beans/spring-beans.xsd10 /schema/context11 /schema/context/spring-context.xsd12 /schema/aop13 /schema/aop/spring-aop.xsd">141516<context:component-scan base-package="com.bie.aop"></context:component-scan>171819<aop:aspectj-autoproxy></aop:aspectj-autoproxy>2021</beans> (4):开始写⼀个切⾯类，源码如下所⽰：1package com.bie.aop;23import ng.annotation.After;4import ng.annotation.Aspect;5import ng.annotation.Before;6import ng.annotation.Pointcut;7import ponent;8910/**11* @author BieHongLi12* @version创建时间：2017年3⽉28⽇下午9:10:4313* @Aspect:指定当前类为切⾯类14*/15 @Component //加⼊到IoC容器16 @Aspect //指定当前类为切⾯类17public class Aop {1819//指定切⼊点表达式，拦截那些⽅法，即为那些类⽣成代理对象20//@Pointcut("execution(* erDao.save(..))") ..代表所有参数21//@Pointcut("execution(* erDao.*())") 指定所有的⽅法22//@Pointcut("execution(* erDao.save())") 指定save⽅法2324 @Pointcut("execution(* erDao.*(..))")25public void pointCut(){2627 }2829 @Before("pointCut()")30public void begin(){31 System.out.println("开启事务");32 }3334 @After("pointCut()")35public void close(){36 System.out.println("关闭事务");37 }3839 } （5）：写好切⾯类就可以写执⾏⽬标对象⽅法，接⼝和实现类如下所⽰： 1package com.bie.aop;23/**4* @author BieHongLi5* @version创建时间：2017年3⽉28⽇下午9:09:296*7*/89public interface IUserDao {1011public void save();12 }1package com.bie.aop;234import ponent;56/**7* @author BieHongLi8* @version创建时间：2017年3⽉28⽇下午9:09:539* ⽬标对象10*/11 @Component12public class UserDao implements IUserDao{1314 @Override15public void save() {16 System.out.println("..核⼼业务--核⼼业务..");17 }181920 } （6）：最后就可以进⾏进⾏测试了，源码如下所⽰：1package com.bie.aop;23import org.junit.Test;4import org.springframework.context.ApplicationContext;5import org.springframework.context.support.ClassPathXmlApplicationContext;67/**8* @author BieHongLi9* @version创建时间：2017年3⽉28⽇下午9:13:1810*11*/12public class AopTest {1314 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");1516//⽬标对象有实现接⼝，spring会⾃动选择"jdk代理【动态代理】"17//动态代理的标识：class com.sun.proxy.$Proxy1018 @Test19public void test01(){20 IUserDao dao = (IUserDao) ac.getBean("userDao");21 System.out.println(dao.getClass());22 dao.save();23 }242526//class com.bie.aop.OrderDao$$EnhancerByCGLIB$$4952a60a27//⽬标对象没有实现接⼝，spring会⽤"cglib代理哦"28 @Test29public void testCglib(){30 OrderDao dao = (OrderDao) ac.getBean("orderDao");31 System.out.println(dao.getClass());32 dao.save();33 }34 } 3：⼼得体会和报错解决： 3.1：虽然案例很简单很简单，但是我花了三四个⼩时，为什么呢！我⽤junit测试spring写的注解实现aop（⾯向切⾯编程）。

spring aop的annotation与xml配置

public class Common {public void execute(String username,String password){System.out.println("------------------普通类----------------");}}2.写一个切面类，用于合法性校验和日志添加：package com.spring.aop;public class Check {public void checkV alidity(){System.out.println("------------------验证合法性----------------");}public void addLog(JoinPoint j){System.out.println("------------------添加日志----------------");Object obj[] = j.getArgs();for(Object o :obj){System.out.println(o);}System.out.println("========checkSecurity=="+j.getSignature().getName());//这个是获得方法名}}3.配置AOP，使用XML 方式：（注意红色标志的内容注意红色标志的内容）<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="common" class="mon"/><bean id="check" class="com.spring.aop.Check"/><aop:config><aop:aspect id="myAop" ref="check"><aop:pointcut id="target" expression="execution(*mon.execute(..))"/><aop:before method="checkValidity" pointcut-ref="target"/><aop:after method="addLog" pointcut-ref="target"/></aop:aspect></aop:config></beans>注意：execution(* com.spring.aop.*.*(..))"/ 这样写应该就可以了这是com.aptech.jb.epet.dao.hibimpl 包下所有的类的所有方法。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

浙江树人大学信息科技学院
实验报告
一、spring基于xml的aop配置
（1）新建maven工程命名为“day03_eeay_springAOP”，在pom.xml中导坐标。

图1 pom.xml
(2)新建业务层接口，在main文件下新建com.itheima.service包，创建IAccountService.java接口，包含模拟保存账户、模拟更新账户、模拟删除账户三个方法。

图2 接口IAccountService
（3）新建业务层实现类，新建com.itheima.service.impl包，创建
AccountServiceImpl.java类。

图3 类AccountServiceImpl
(4)新建一个具有公共代码的类，新建com.itheima.utils包，创建Logger.java,用于记录日志的工具类，他里面提供了公共的代码。

图4 类Logger
(5)配置spring文件，在resources下新建bean.xml，导入ioc约束，配置spring 的ioc，配置spring中的基于XML的AOP。

图5 配置bean.xml文件
（6）编写测试类，新建com.itheima.test包，创建AOPTest.java用来测试AOP配置。

图6 测试类AOPTest
【结果】
结果图1 AOPTest
三、spring基于注解的aop配置
（1）新建maven工程命名为“day03_eesy_apringAOP”，将上一个pom.xml中的坐标和工程的文件复制过来。

图7 pom.xml
（2）修改bean.xml文件，改为ioc的注解，添加配置spring创建容器时要扫描的包和配置spring开启注解AOP的支持。

图8 bean.xml
（3）在账户的业务层实现类中，AccountServiceImpl.java里添加@Service注解。

图9类AccountServiceImpl
(4)在记录日志的工具类中，Logger.java里添加@Component注解，@Aspect：表示当前类是一个切面类，在每个通知前都加上相对应的注解。

图9 类Logger
（5）注释环绕通知注解，运行程序，得出实验结果
结果图2
（6）注释四个通知注解，使用环绕通知注解，运行程序，得出实验结果。

结果图3
心得体会
通过这次实验知道了什么是AOP（Aspect Oriented Programming）,即面向切面编程（也叫面向方面编程，面向方法编程）。

其主要作用是,在不修改源代码的情况下给某个或者一组操作添加额外的功能。

像日志记录,事务处理,权限控制等功能,都可以用AOP来“优雅”地实现,使这些额外功能和真正的业务逻辑分离开来，软件的结构将更加清晰。

AOP是OOP的一个强有力的补充。

还知道了AOP的7个专业术语
1.增强（Advice）：增强就很好理解了，AOP（切面编程）是用来给某一类特殊的连接点，添加一些特殊的功能，那么我们添加的功能也就是增强啦~比如：添加日志、管理事务。

2.切点（Pointcut）：一个项目中有很多的类，一个类有很多个连接点，当我们需要在某个方法前插入一段增强（advice）代码时，我们就需要使用切点信息来确定，要在哪些连接点上添加增强。

3.连接点(Joinpoint)：连接点就是程序执行的某个特定的位置，如：类开始初始化前、类初始化后、类的某个方法调用前、类的某个方法调用后、方法抛出异常后等。

Spring 只支持类的方法前、后、抛出异常后的连接点。

4.切面(Aspect)：切面由切点和增强(或引介)组成，或者只由增强（或引介）实现。

5.目标对象（Target）：目标对象就是我们需要对它进行增强的业务类~如果没有AOP，那么该业务类就得自己实现需要的功能。

6.AOP代理(AOP proxy)：一个类被AOP织入后生成出了一个结果类，它是融合了原类和增强逻辑的代理类。

7.织入(Weaving)：织入就是将增强添加到目标类具体连接点上的过程。