Spring_IoC注解开发和AOP的XML开发(学习笔记2）

一：IoC注解开发

1，在applicationContext.xml中需要引入context约束

 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- bean definitions here -->

 </beans>

2,简单的注解开发实例

   <!-- 进行IoC注解开发，首先在配置文件里配置组件扫描，即哪个包下的类进行注解开发 -->
     <context:component-scan base-package="com.test.spring.demo1"/>

 @Component("userDao")
 public class UserDaoImp implements UserDao {
     @Value("三八")
     private String name;
     @Override
     public void save() {
         System.out.println("UserDaoImp的save方法执行了"+name);
     }

 }

注意：对于要实现的类中的属性注入，可以不提供该属性的set方法，如果提供了，将@Value的注解加在set方法上发即可

3,IoC注解详情

@Component

修饰一个类，将这个类交给Spring管理，有三个衍生注解（功能相似）建议用衍生的三个注解

1. @Controller(web 层）
2. @Service(service 层）
3. @Repository(dao 层）

 @Repository("userDao")
 public class UserDaoImp implements UserDao {
     @Value("三八")
     private String name;
     @Override
     public void save() {
         System.out.println("UserDaoImp的save方法执行了"+name);
     }

 }

属性注入的注解

• @Value(” “）注入普通属性，并设置属性的值
• @Autowired    注入对象属性，根据对象类型来注入,但一般是按照名称来注入，需要搭配注解@Qualifier(value="名称”
• @Resource(name="名称")  根据名称注入对象属性，常用

 @Service("userService")
 public class UserServiceImp implements UserService {
     //注入UserDao
     /*@Autowired
     @Qualifier(value="userDao")*/
     @Resource(name="userDao")
     private UserDao userDao;
     @Override
     public void save() {
         System.out.println("UserService的save方法执行了");
         userDao.save();
     }
 }

其他注解：

• @PostConstruct   初始化方法
• @PreDestroy  销毁方法
• @Scope("singleton&prototype&request&session&globalsession")  作用范围的注解，默认为singleton,单例

 @Service("customerService")
 @Scope
 public class CustomerServiceImp implements CustomerService {
     @PostConstruct
     public void Init(){
         System.out.println("init");
     }
     @Override
     public void save() {
     }
     @PreDestroy
     public void Destroy(){
         System.out.println("destroy");
     }
 }

4，xml和注解的区别和整合开发

注解与XML配置的区别

注解：是一种分散式的元数据，与源代码紧绑定。

xml：是一种集中式的元数据，与源代码无绑定。

详情：https://www.cnblogs.com/iOS-mt/p/6133656.html

xml和注解的整合开发（了解）

注意：bean管理交给xml,属性注入交给注解

 <bean id="customerService" class="com.test.spring.demo2.CustomerServiceImp"/>
 <bean id="productDao" class="com.test.spring.demo2.ProductDao"/>
 <!-- 需要开启以下配置，在没有扫描的情况下，能够使用注解将属性注入 @Value @Resource @Autowired @Qualifier-->
 <context:annotation-config />

二,AOP（Aspect Oriented Programming）面向切面编程

参考：http://www.cnblogs.com/xrq730/p/4919025.html

AOP的作用简单图示：

​​

1，底层原理为动态代理（反射）

• JDK动态代理：只能对实现了接口的类进行代理
• Cglib动态代理：（类是于Javasist第三方代理技术),可以对没有实现接口的类实现代理，生成子类对象

 //Cglib动态代理简单实现，增强UserDao中的save方法
 public class UserDaoProxy implements MethodInterceptor{
     private UserDao userDao;

     public UserDaoProxy(UserDao userDao) {
         super();
         this.userDao = userDao;
     }

     public UserDao createProxy(){
         //1,获取Cglib动态代理核心类
         Enhancer enhancer=new Enhancer();
         //2，设置父类
         enhancer.setSuperclass(userDao.getClass());
         //3,设置回调：(类似于    InvocationHandler对象)
         enhancer.setCallback(this);
         //4,创建代理对象
         UserDao proxy = (UserDao) enhancer.create();
         return proxy;
     }

     @Override
     public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
         if("save".equals(method.getName())){
             System.out.println("增强代码");
             return methodProxy.invokeSuper(proxy, args);
         }
         return methodProxy.invokeSuper(proxy, args);
     }
 }

2,AOP的相关术语：

• Joinpoint（连接点，可以被增强/切入的方法都可以被称为连接点）
• Pointcut（切入点，真正被增强的连接点被称为切入点）
• Advice（通知/增强，增强的相关代码或方法）
• Introduction（引介，类层面的增强，即向类里直接加入增强的代码）
• Target（目标，被增强的对象）
• weaving（织入，将Advice引入到Target的过程）
• Proxy（代理，通过AOP织入后的类）
• Aspect（切面，多个通知和多个切入点的组合）

注意：切入点可以是一个包下的单个类的单个方法,也可以是一个或多个包下的多个类的多个方法，需要灵活配置

3,基于aspectJ的aop的xml开发简单入门

1）引入相应的jar包

​​​

2）在配置文件中引入aop的schema约束

 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->

 </beans>

3)编写目标类

 public class ProductDaoImp implements ProductDao {

     @Override
     public void save() {
         System.out.println("product保存");
     }

     @Override
     public void delete() {
         System.out.println("product删除");
     }

 }

4）编写切面类

 public class MyAspectXml {
     public void checkPriviledge(){
         System.out.println("权限校验代码=========");
     }
 }

5）xml的配置

  <!-- 配置目标对象 -->
     <bean id="productDao" class="com.test.demo1.ProductDaoImp"></bean>
     <!-- 配置切面类 -->
     <bean id="myAspect" class="com.test.demo1.MyAspectXml"></bean>
     <!-- 配置AOP对目标对象产生代理 -->
     <aop:config>
         <!-- 配置切入点 -->
         <aop:pointcut expression="execution(* com.test.demo1.ProductDaoImp.save(..))"
             id="pointcut1" />
         <!-- 配置切面 -->
         <aop:aspect ref="myAspect">
             <aop:before method="checkPriviledge" pointcut-ref="pointcut1" />
         </aop:aspect>
     </aop:config>

4,advice(通知）类型

1）前置通知

仅能获取到切入点信息（所有类型的通知都可以获取）

 public class MyAspectXml {
     public void checkPriviledge(JoinPoint joinpoint){
         System.out.println("权限校验代码========="+joinpoint);
     }
 }

2）后置通知

能够获取切入点的返回值

 public void writeLog(Object obj){
         System.out.println("日志代码========="+obj);
     }

 <!-- 后置通知 -->
 <aop:after-returning method="writeLog" pointcut-ref="pointcut2" returning="obj"/>    

3）环绕通知

在切入点的前后都执行相关的增强代码，可以阻止切入点的执行（如对切入点进行事务处理）

 public void round(ProceedingJoinPoint joinPoint) throws Throwable{
         System.out.println("环绕前代码========");
         //执行切入点的方法
         joinPoint.proceed();
         System.out.println("环绕后代码========");
     }

  <!-- 环绕通知 -->
 <aop:around method="round" pointcut-ref="pointcut3"/>

4）异常通知

当所应用/通知的切入点，运行异常时，会执行异常通知，也可以对异常抛出

 public void afterThrowing(Throwable ex){
         System.out.println("异常抛出通知代码====="+ex.getMessage());
     }

   <!-- 异常通知 -->
 <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="ex"/>    

5）最终通知

无论切入点是否有异常，最终通知的代码都会执行

  <!-- 最终通知 -->
 <aop:after method="after" pointcut-ref="pointcut4"/>

5，切入点表达式

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

访问修饰符可以省略，访问返回值类型可以用 * 代替，表示任意类型，参数 .. 代替，表示任意参数 用 * 可以灵活配置切入点

例： * *.*.*(..)  表示任意包的的所有类下的说有方法配置为一个切入点

* com.test.dao.UserDao+.save(..) 表示UserDao类及其子类的save方法配置为一个切入点