1. 1.问题：
    代码混乱：越来越多的非业务需求(日志和验证等)加入后, 原有的业务方法急剧膨胀.
     每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点.
    代码分散: 以日志需求为例, 只是为了满足这个单一需求, 就不得不在多个模块（方法）里多次重复相同的日志代码.
如果日志需求发生变化, 必须修改所有模块.

解决： AOP
        AOP（Aspect Oriented Programming），即面向切面编程，
        可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。
        OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。
        不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。
        日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，
        如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），
        在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

     AOP技术恰恰相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，
     并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。
     所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，
     便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，
与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，
而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。


AOP(Aspect-Oriented Programming, 面向切面编程): 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming,
面向对象编程) 的补充.
AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点.
在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用, 并且不必修改受影响的类. 这样一来横切关注点就被模块化到特殊的对象(切面)里.


<!-- 声明增强方法所在的bean -->
      <bean id="the" class="cn.kgc.aop.UserServiceLo"></bean>
      
      <!-- 配置切面 -->
      <aop:config>
      	<!-- 定义切入点 -->
      	  <aop:pointcut expression="execution(public void addNewUser(cn.kgc.pojo.User))" id="pointcut"/>
      	  <!-- ref:指的就是声明增强的类的对象 -->
      	  <aop:aspect ref="the">
      	  	<aop:before method="before" pointcut-ref="pointcut"/>
      	  	<aop:after-returning method="after" pointcut-ref="pointcut" />
      	  </aop:aspect>
      </aop:config>

//增强类的对象 
public class UserServiceLo {
	    private static final Logger log=Logger.getLogger(UserServiceLo.class);
	    
	       public void before(){
	    	   System.out.println("日志功能");
	       }
	       	       
	       public void after(){
	    	   System.out.println("事务控制功能");
	       }
}


1.代理设计模式：   java里常用的设计模式
       特点：  1.具体类和代理类有相同的接口或者共同的父类
       2.代理类为具体类负责消息的处理，并将消息转发给具体类
       3.代理类本身并不是真正的实现者，而是通过调研具体类的方法来实现的
       
2.按照代理类创建的时机，分两类：
    1.静态代理：  是有我们程序员或者是特定的工具生成的
       
    
    2.动态代理：  在程序运行期间，通过反射的方式动态的创建出来的
       2.1： jdk动态代理（接口）：
                                             必须知道一个类和一个接口
                  InvocationHandler 只有一个方法
                  
                  public Object invoke(Object proxy,Method method,Object[] args) throws Throwable 
                  
                  proxy:代理类的对象
                  method： 被代理的方法
                  args：被代理的方法的参数列表
       2.2： Proxy:类
               
               
               
 3. aop:  1.Advice(增强代码功能的类)  
          2.织入（Weaving）：对方法进行增强：
                1.前置增强：  在目标方法前调用
                
               2.后置增强：   在目标方法后调用
               
               
              3.环绕增强、：可以把前置  后置  异常抛出增强、最终增强等合到一起
              
              
                                           异常抛出增强、最终增强等类型
                                           
                                           
              4.Pointcut（切入点）： 就是带有通知的连接点，在程序里主要体现为书写切入点的表达式：
              
              
              5.Join Point：（连接点）：程序执行过程里明确的一个点，一般就是方法的调用
              
              6.Aspect（切面）：  通常指的是一个类（里面可以指定切入点和通知）  

aop:好处：每个事物逻辑位于一个位置，代码不分散，便于维护和升级
业务模块更简洁了，只包含核心的业务代码

spring:spring里aop代理由spring的IOC容器负责生产，管理，其依赖关系由IOC容器负责管理，因此AOP代理可以直接使用容器里的其他bean 实例作为目标。