spring-01

1、spring的简介

　　Spring 是一个开源框架，为简化企业级应用开发而生。Spring 可以使简单的 JavaBean 实现以前只有 EJB 才能实现的功能。Spring 是一个 IOC 和 AOP 容器框架。

IOC容器：控制反转， 反转控制， 反向控制

　　将对象的生命周期控制权利，交给Spring容器管理。原有开发方式，对象生命周期由程序员通过代码控制.。如: new关键字. setter方法调用, xxx = null.

1）控制反转中控制指的是：控制类的对象

2）控制反转中反转指的是转交给 Spring 负责

3）IoC 最大的作用：解耦(程序员不需要管理对象.解除了对象管理和程序员之间的耦合)

2、Spring的DI：依赖注入

　　当一个类(A)中需要依赖另一个类(B)对象时，把 B 赋值给 A 的过程就叫做依赖注入

3、spring的注入的种类和方式

1）构造方法注入（通过构造方法的参数,为对象的属性赋值）

2）setter注入（Spring容器针对bean对象的property实现属性注入.面向getter方法和setter方法实现的属性数据赋值. 每次为属性赋值,调用的是setXxxx方法）

3）静态工厂的方法注入

4）实例工厂的方法注入

1 //字符串注入  2 private String msg;  3 //int类型注入  4 private int flag;  5 //String类型数组注入      6 private String[] array;  7 //int类型数组注入  8 private int[] array2;  9 //list注入 10 private List
      
        list; 11 //其他对象类型 12 private List
       
         uds; 13 //set 14 private Set
        
          sets; 15 //map 16 private Map
         
           maps; 17 //Properties 18 private Properties prop; 19      20 public Properties getProp() { 21     return prop; 22 } 23  24 public void setProp(Properties prop) { 25     Set
          
         
        
       
      

1 
       2 
       3 
       4 
      
        5     
       
         6         
        
         dilraba
         7         
        
         tom
         8         
        
         java
         9     
       10 
      11 
      
       12     
       
        13         
        
         111
        14         
        
         222
        15         
        
         333
        16     
       17 
      18 
      
       19     
       
        20         
        
         fasdfas
        21         
        
         fdfafgf
        22     
       23 
      24 
      
       25     
       
        26         
        27     
       28 
      29 
      
       30     
       
        31         
        
         sets1
        32         
        
         sets2
        33     
       34 
      35 
      
       36     
       45 
      46 
      
       47     
       
        48         
        
         prop11
        49         
        
         prop22
        50     
       51 
      

属性注入小结（必须要有set方法）

　　属性注入通过property标签，注入String+八种基本数据类型用value标签，注入的是IOC容器自己的对象用ref，如果注入实体类对象，用bean标签缓存一下。

 Spring IOC注入方式用得最多的是(1)(2)种，通过Spring创建的对象默认是单例，如果需要创建多实例对象可以在<bean>标签后面添加一个属性：=

 4、面向切面编程（AOP）

　　在面向对象编程（oop）思想中，我们将事物纵向抽成一个个的对象。而在面向切面编程中，我们将一个个的对象某些类似的方面横向抽成一个切面，对这个切面进行一些如权限控制、事物管理，记录日志等公用操作处理的过程就是面向切面编程的思想。AOP 底层是动态代理，如果是接口采用 JDK 动态代理，如果是类采用CGLIB 方式实现动态代理。

一些俗语的理解：

切面(aspect)：动态代理对象

连接点(joinpoint)：AOP可以是方法，属性，构造方法，都可以拦截。spring中仅支持对方法的拦截 

切点(pointcut)：动态代理拦截的目标，如动态代理的invoke

通知(advice)：前置，后置，环绕

Spring 切面可以应用五种类型的通知

1）方法的前置通知（before）

实现接口：MethodBeforeAdvice

功能：在目标方法(被代理的对象的方法)调用前,做什么

方法：void before(Method method, Object[] args, Object proxy)

主要应用于：记录日志 | 开启事务 | 其他功能处理

2）方法的后置通知（after  / after-returning）

after：在方法执行之后调用的通知，无论方法执行是否成功。

after-returning：仅当方法成功完成后执行的通知

3）方法异常通知（after-throwing）

实现接口：ThrowsAdvice

功能：在方法抛出异常退出时执行的通知

方法：void afterThrowing(RuntimeException e)

4）方法环绕通知（around）

实现接口：MethodInterceptor

方法：Object invoke(MethodInvocation arg0) throws Throwable

功能：在方法执行之前和之后调用的通知

目标(target)：被代理的对象

织入(weave)：目标和拦截对象捏合到一起的过程

springAOP：面向切面编程，是将纵向执行的流程。进行横向的切面，增加额外的功能。

切入的设计目标：使程序进行插拔式的开发，切的controller和service层之间。

代理模式：为真正处理业务的对象，提供附属功能的类型，称为代理。在不改变真正处理业务对象的代码前提下，为方法逻辑。增加新的功能的方式。

静态代理：代理对象专门为某一个对象或类型，提供针对性的服务支撑。功能全面强大，针对性强。缺陷是通用性降低。

动态代理：代理对象为某一类事务提供辅助功能支撑。通用性高，针对性不足。

静态代理代码实现

①定义接口：租赁接口，谁实现了这个接口，代表具有租赁能力，对外出租给第三方

1 package com.boom.staticproxy; 2 /** 3  * 租赁接口，谁实现了这个接口，代表具有租赁能力，对外出租给第三方 4  * @project_name proxy  5  * @class_name Rent 6  * @author Dilraba 7  */ 8 public interface Rent { 9     //定义一个房源10     public void rent();11 12 }

②业主，房屋的持有者，实现了租赁接口

1 package com.boom.staticproxy; 2 /** 3  * 业主, 房屋的持有者 4  * @project_name proxy  5  * @class_name Host 6  * @author Dilraba 7  */ 8 public class Host implements Rent{ 9 10     //出租的具体详情11     @Override12     public void rent() {13         System.out.println("签合同,交钱...");14     }15     16 17 }

③代理对象，俗称二手房东等

1 package com.boom.staticproxy; 2 /** 3  * 代理对象 4  * @project_name proxy  5  * @class_name ProxyObject 6  * @author Dilraba 7  */ 8 public class ProxyObject implements Rent { 9 10     private Host host;11     12     public ProxyObject() {13     }14     public ProxyObject(Host host) {15         this.host = host;16     }17     18     @Override19     public void rent() {20         System.out.println("带顾客看房子....");21         host.rent();22         System.out.println("后期的一些乱七八糟事情。。。。");23     }24     25 }

④模拟客户租房子

1 package com.boom.staticproxy; 2 /** 3  * 模拟客户租房子 4  * @project_name proxy  5  * @class_name StaticProxy 6  * @author Dilraba 7  */ 8 public class TestProxy { 9     public static void main(String[] args) {10         //创建客户11         Host t = new Host();12         //创建代理对象(二手房东)13         ProxyObject po = new ProxyObject(t);14         po.rent();15     }16 }

静态代理代码实现

①定义接口

1 package com.boom.dynamicproxy; 2 /** 3  * 租赁接口，谁实现了这个接口，代表具有租赁能力，对外出租给第三方 4  * @project_name proxy  5  * @class_name Rent 6  * @author Dilraba 7  */ 8 public interface Rent { 9     //定义一个房源10     public void rent();11 12 }

②实现接口

1 package com.boom.dynamicproxy; 2 /** 3  * 业主, 房屋的持有者 4  * @project_name proxy  5  * @class_name Host 6  * @author Dilraba 7  */ 8 public class Host implements Rent{ 9 10     //出租的具体详情11     @Override12     public void rent() {13         System.out.println("签合同,交钱...");14     }15     16 17 }

③动态代理：实现了InvocationHandler调用其invoke方法

1 package com.boom.dynamicproxy; 2  3 import java.lang.reflect.InvocationHandler; 4 import java.lang.reflect.Method; 5  6 /** 7  * 代理对象 8  * @project_name proxy  9  * @class_name DynamicProxy10  * @author Dilraba11  */12 public class DynamicProxy implements InvocationHandler {13 14     private Object obj;15     public DynamicProxy() {16         17     }18     19     public DynamicProxy(Object obj) {20         super();21         this.obj = obj;22     }23 24     /**25      * @param proxy - 代理对象26      * @param method - 真实的方法, 就是要调用的最终方法. 业主出租访问的方法.27      * @param args - 真实方法要执行的时候,需要的参数.28      */29     @Override30     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {31         System.out.println("Advice...Before");32         System.out.println(proxy.getClass().getName());33         Object obj =  method.invoke(this.obj, args);34         System.out.println("Advice...After");35         return obj;36     }37     38 }

④测试

1 package com.boom.dynamicproxy; 2  3 import java.lang.reflect.Proxy; 4  5 /** 6  *  7  * @project_name proxy  8  * @class_name TestProxy 9  * @author Dilraba10  */11 public class TestProxy {12     public static void main(String[] args) {13         Host host = new Host();14         DynamicProxy dp = new DynamicProxy(host);15         Rent rent = (Rent)Proxy.newProxyInstance(host.getClass().getClassLoader(), host.getClass().getInterfaces(), dp);16         System.out.println(rent);//就是代理对象：com.boom.dynamicproxy.Host@6bc7c05417         rent.rent();18     }19 }

5、Spring中AOP的开发四种方式(Spring中对于 AOP配置底层基于动态代理)

xml方式配置：在spring任意版本中都可以使用，缺：只能配置一个业务层，若业务层繁多做切面配置时候，配置信息繁琐，不便于管理。

①springAOP-xml.xml

1 
       2 
       3 
      
        7     
        8 
        9     
       10 
       11 12 
       
        13     
        
         14         
         15     
        16     
        
         17         
         
          com.boom.xml.service.UserService
         18     
        19     
        
         20         
         
          21             
          
           myAOP
          22         
         23     
        24 
       25 
      

②接口和实现类

1 package com.boom.xml.service;2 3 public interface UserService {4     5     void addUser();6 }

1 package com.boom.xml.service.impl; 2  3 import com.boom.xml.service.UserService; 4  5 public class UserServiceImpl implements UserService { 6  7     @Override 8     public void addUser() { 9         System.out.println("UserService...");10     }11     12 }

③AOP

1 package com.boom.xml.aop; 2  3 import java.lang.reflect.Method; 4 import java.lang.reflect.Proxy; 5  6 import org.aopalliance.intercept.MethodInterceptor; 7 import org.aopalliance.intercept.MethodInvocation; 8 import org.springframework.aop.AfterReturningAdvice; 9 import org.springframework.aop.MethodBeforeAdvice;10 import org.springframework.aop.framework.ProxyFactoryBean;11 12 public class MyAOP implements MethodBeforeAdvice, AfterReturningAdvice, MethodInterceptor {13 14     @Override15     public Object invoke(MethodInvocation arg0) throws Throwable {16         System.out.println("AOP联盟...before");17         Object obj = arg0.proceed();18         System.out.println("AOP联盟...after");19         return obj;20     }21 22     @Override23     public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {24         System.out.println("Spring...after");25         26     }27 28     @Override29     public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {30         System.out.println("Spring...before");31     }32 33 }

④测试类

1 package com.boom.xml.test; 2  3 import org.springframework.context.ApplicationContext; 4 import org.springframework.context.support.ClassPathXmlApplicationContext; 5  6 import com.boom.xml.service.UserService; 7  8  9 public class Test {10     public static void main(String[] args) {11         //启动spring框架12         ApplicationContext ac = new ClassPathXmlApplicationContext("springAOP-xml.xml");13         UserService us = (UserService)ac.getBean("userServieAOP");14         us.addUser();15         16     }17 }

⑤运行结果

spring aspect：在配置文件里配置<aop:config>，<aop:advisor>配置前置后置环绕等通知。

①springAOP-springaspect.xml 

1 
       2 
       3 
       7 
      
       17     
       18 
       19     
       20     
       21     
       22     
       23     
       24     25     
       
        26         
        27         
        28         
        29         
        30         
        31     
       32 
      

②接口和实现类

1 package com.boom.springaspect.service;2 3 public interface UserService {4 5     String addUser();6 }

1 package com.boom.springaspect.service.impl; 2  3 import com.boom.springaspect.service.UserService; 4  5 public class UserServiceImpl implements UserService { 6  7     public String addUser() { 8         System.out.println("addUser.........."); 9         return "aaa";10     }11 12 }

③AOP

1 package com.boom.springaspect.aop; 2  3 import java.lang.reflect.Method; 4  5 import org.springframework.aop.MethodBeforeAdvice; 6  7 public class MyBeforeAdvice implements MethodBeforeAdvice { 8  9     @Override10     public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {11         System.out.println("Before.......");12     }13 14 }

1 package com.boom.springaspect.aop; 2  3 import java.lang.reflect.Method; 4  5 import org.springframework.aop.AfterReturningAdvice; 6  7 public class MyAfterAdvice implements AfterReturningAdvice { 8  9     @Override10     public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {11         System.out.println("After....");12     }13 14 }

1 package com.boom.springaspect.aop; 2  3 import org.aopalliance.intercept.MethodInterceptor; 4 import org.aopalliance.intercept.MethodInvocation; 5  6 public class MyAroundAdvice implements MethodInterceptor { 7  8     @Override 9     public Object invoke(MethodInvocation arg0) throws Throwable {10         System.out.println("AOP......Before");11         Object obj = arg0.proceed();12         System.out.println("AOP.......After");13         return obj;14     }15 16 }

1 package com.boom.springaspect.aop; 2  3 import org.springframework.aop.ThrowsAdvice; 4  5 public class MyThrowsAdvice implements ThrowsAdvice { 6  7     public void afterThrowing(RuntimeException e){ 8         System.out.println(e.getClass().getName()); 9     }10 }

④测试

1 package com.boom.springaspect.test; 2  3 import org.springframework.context.ApplicationContext; 4 import org.springframework.context.support.ClassPathXmlApplicationContext; 5  6 import com.boom.springaspect.service.UserService; 7  8  9 public class Test {10 11     public static void main(String[] args) {12         ApplicationContext ac = new ClassPathXmlApplicationContext("springAOP-springaspect.xml");13         UserService us = (UserService)ac.getBean("userService");14         us.addUser();15     }16 17 }

⑤运行结果

spring aspectj 方式：(spring 2.0以后引入)是专门做springAOP一个框架/技术，一开始并不是spring的，后来被spring收购了。AOP比xml更加通  用，简化。AspectJ不属于spring的标准技术，所以切面不需要实现spring中的通知接口。AspctJ的特点是通过方法+配置文件来定义aop

①springAOP-aspectj.xml

1 
       2 
       3 
      
       13     
       14     
       15     
       16     
       17     
       18     
       
        19     
        20         
        
         21         
         22             
         23             
         24             
         25             
         26         
        27     
       28 
      

②接口和实现类

1 package com.boom.aspectj.service;2 3 public interface UserService {4     5     void addUser();6 }

1 package com.boom.aspectj.service.impl; 2  3 import com.boom.aspectj.service.UserService; 4  5 public class UserServiceImpl implements UserService { 6  7     @Override 8     public void addUser() { 9         System.out.println("UserService...");10     }11     12 }

③AOP

1 package com.boom.aspectj.aop; 2  3 import org.aspectj.lang.ProceedingJoinPoint; 4 /** 5  * AspectJ不属于spring的标准技术，所以切面不需要实现spring中的通知接口 6  * AspctJ的特点是通过方法+配置文件来定义aop 7  * @project_name springAOP  8  * @class_name MyAOPAspectj 9  * @author Dilraba10  */11 public class MyAOPAspectj {12     public void doBefore(){13         System.out.println("Before...");14     }15     public void doAfter(Object obj){16         System.out.println("After...");17     }18     public void doAfterThrowing(RuntimeException ex){19         System.out.println(ex.getClass().getName());20         System.out.println("doAfterThrowing...");21     }22     public void doAround(ProceedingJoinPoint joinPoint) throws Throwable{23         System.out.println("doAround...before");24         joinPoint.proceed();25         System.out.println("doAround...after");26     }27 }

④测试

1 package com.boom.aspectj.test; 2  3 import org.springframework.context.ApplicationContext; 4 import org.springframework.context.support.ClassPathXmlApplicationContext; 5  6 import com.boom.aspectj.service.UserService; 7  8  9 public class Test {10 11     public static void main(String[] args) {12         ApplicationContext ac = new ClassPathXmlApplicationContext("springAOP-aspectj.xml");13         UserService us = (UserService)ac.getBean("userService");14         us.addUser();15         16     }17 18 }

⑤运行结果

spring annotation：需要使用Spring的注解和AspectJ的注解(注解就是)

①springAOP-annotation.xml

1 
       2 
       3 
       7 
      
       16     17     
       18     
       19     
       20     
       21     
       22 
      

②接口和实现类

1 package com.boom.annotation.service;2 3 public interface UserService {4     void addUser();5 }

1 package com.boom.annotation.service.impl; 2  3 import org.springframework.stereotype.Service; 4  5 import com.boom.annotation.service.UserService; 6  7 @Service 8 public class UserServiceImpl implements UserService { 9 10     @Override11     public void addUser() {12         System.out.println("addUser........");13 14     }15 16 }

③AOP

1 package com.boom.annotation.aop; 2  3 import org.aspectj.lang.ProceedingJoinPoint; 4 import org.aspectj.lang.annotation.After; 5 import org.aspectj.lang.annotation.Around; 6 import org.aspectj.lang.annotation.Aspect; 7 import org.aspectj.lang.annotation.Before; 8 import org.aspectj.lang.annotation.Pointcut; 9 import org.springframework.stereotype.Component;10 11 @Aspect12 @Component13 public class MyAOP {14     15     @Pointcut("execution(* com.boom.annotation.service.*.*(..))")16     public void suibian(){17         18     }19     20     @Before("suibian()")21     public void doBefore(){22         System.out.println("doBefore......");23     }24     25     @After("suibian()")26     public void doAfter(){27         System.out.println("doAfter");28     }29     30     @Around("suibian()")31     public void around(ProceedingJoinPoint joinPoint)throws Throwable{32         System.out.println("around.....before");33         joinPoint.proceed();34         System.out.println("around.....after");35     }36 }

④测试

1 package com.boom.annotation.test; 2  3 import org.springframework.context.ApplicationContext; 4 import org.springframework.context.support.ClassPathXmlApplicationContext; 5  6 import com.boom.annotation.service.UserService; 7  8  9 public class Test {10 11     public static void main(String[] args) {12         //spring启动13         ApplicationContext ac = new ClassPathXmlApplicationContext("springAOP-annotation.xml");14         UserService us = (UserService)ac.getBean(UserService.class);15         us.addUser();16     }17 18 }

⑤运行结果