Spring Java Bean作用域，添加junit单元测试及AOP

Java Bean的作用域:

1. singleton:单例模式,无论spring的容器中新创建多少个bean实例对象,他们都始终指向同一个对象.
2. Prototype:原型模式,指的就是容器重新创建一个新的bean实例化对象,每个对象都可以有自己的作用属性和状态.
3. Request:请求域,存在于http请求中,同一个访问地址返回同一个bean实例,不同的请求返回不同的bean实例。
4. Session:Session作用域,在一次HttpSession中，容器会返回同一个bean实例,仅当session失效之后被销毁。
5. global Session:在同一个全局的Http Session中返回一个bean实例。

导入spring进行单元测试的相关依赖

1. 
           <!--junit依赖-->
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>4.13</version>
           </dependency>
    
           <!--spring整合junit的jar包-->
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-test</artifactId>
               <version>5.2.9.RELEASE</version>
           </dependency>
   

   
   接下来，需要在进行单元测试的类的头上加上两行代码，
   1，使用@RunWith注解，该注解就是一个运行器，SpringJUnit4ClassRunner.class所谓参数添加到其中，目的在于让junit单元测试在spring环境下运行。
   2，@ContextConfiguration 注解（应用上下文配置）：告诉spring，ioc容器是使用xml的还是通过注解的形式去实现，参数可不限于一种表达方式，可以采用value=｛"classpath:spring.xml"｝，还可采用locations="classpath:beans.xml"。这里的xml文件名看你是怎么取的，还可以采用classes=SpringConfigruation.class的形式去实现，SpringCongiguration类是一个配置类。

Java中的常见术语

1.OO(obiect orented)面向对象

2.OOA(object orented analyse)

3.OOP(object orented programing)

4.AOP(aspect orented programing)

Aop(面向切面编程)

何谓面向切面编程,就是在对于java中具体的方法进行操作的时候,在方法执行前后添加一个新的操作,比如在进行账号注册之前进行账号名密码校验,一般面向切面编程都是为了处理一些程序中方法前后执行逻辑或者对于完整方法进行优化。

动态代理

请看下面这么一段代码：我们有一个UserDao，在UserDaoTest里的main方法创建了一个UserDao对象。然后嗲用saveUser方法。执行结果大家都能猜到，会输出"user dao save user"。

public class UserDao { 
    public void saveUser(){ 
        System.out.println("user dao save user"); 
    }
 }

public class UserDaoTest {
 public static void main(String [] args) { 
        UserDao userDao = new UserDao(); 
        userDao.saveUser();
    } 
}

需求：随着系统的升级，我们需要对一些方法的调用进行日志输出，目前我们要在不改变saveUser源码的情况下，在saveUser前和调用完成之后输出一些其它内容。

问题：有哪些方法可以做到?

解决方案：通过代理来完成，代理分静态代理和动态代理

代理是什么？

答：代理就如同桌面的快捷方式，通过双击快捷方式能起到和双击真实执行程序一样的效果。

动态代理三个关键点：

1. 真实对象对象必须是要实现某个接口

2. 对真实对象的调用逻辑要在InvocationHandler接口里做

3. 使用Proxy.newProxyInstance完成代理对象的创建

public interface IUserDao { 
    void saveUser(); 
}

public class UserDao implements IUserDao{
    public void saveUser(){ 
        System.out.println("user dao save user"); 
    }
}

public class UserDaoTest { 
    public static void main(String [] args) { 
        // 真实对象 
        final UserDao userDao = new UserDao(); 
        // 代理对象（快捷方式） IUserDao iUserDao = (IUserDao)                 
        Proxy.newProxyInstance(UserDao.class.getClassLoader(), 
        new Class[]{IUserDao.class}, new InvocationHandler() {
             public Object invoke(Object proxy, Method method, Object[] args) throws         
             Throwable {
                 //调用真实对象前要做的事 
                 System.out.println("before..");
                 // 调用真实对象要做的事（真正的执行的程序） 
                Object invoke = method.invoke(userDao, args); 
                //调用真实对象完成后要做的事 System.out.println("after..");
                 return invoke; }
             });
             // 双击快捷方式 
             iUserDao.saveUser(); 
        }
     }