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管理，有三个衍生注解（功能相似）建议用衍生的三个注解

@Controller(web 层）
@Service(service 层）
@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方法配置为一个切入点

巴特西