spring

软件工程框架：

        经过验证的，具有一定功能的，半成品软件

               经过验证

               具有一定功能

               半成品

框架的作用：

        1.提高开发效率

        2.增强可重用性

        3.提供编写规范

        4.节约维护成本

        5.解耦底层实现原理

Spring：

        spring是分层的JavaSE/EE应用full-stack，轻量级，开源的，半成品框架，以IOC（Inverse of control:反转控制）和AOP（Aspect Oriented Programming：面向切面编程）为内核。

Spring优势：

        1.方便解耦，简化开发

        2.方便集成各种优秀的框架

        3.方便程序的测试

        4.切面编程的支持

        5.声明式事务的支持@Transational

        6.降低JavaEE API的使用难度

IOC反转控制：本质功能就是由spring IOC 容器来负责对象的生命周期和对象之间的关系

DI：依赖注入

        两种方式：set注入，构造注入

bean的生命周期：

singleton：单例模式

实例化时机:当Spring核心文件被加载时，实例化配置的Bean实例

        对象创建：当应用加载，创建容器时，对象就被创建了

        对象运行：只要容器在，对象一直活着

        对象销毁：当应用卸载，销毁容器时，对象就被销毁了

prototype：多例模式

 实例化时机:当调用getBean()方法时实例化Bean

        对象创建：当使用对象时，创建新的对象实例

        对象运行：只要对象在使用中，就一直活着

         对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了 （ jvm gc垃圾回收）

spring的原始注解：

        注解                                        说明

@Component                 使用在类上用于实例化Bean

@Controller                    使用在web层类上用于实例化Bean

@Service                        使用在service层类上用于实例化Bean

@Repository                   使用在dao层类上用于实例化Bean

@Autowired                    使用在字段上用于根据类型依赖注入

@Qualifier                       结合@Autowired一起使用用于根据名称进行依赖注入

@Resource                      相当于@Autowired+@Qualifier, 按照名称进行注入

@Value                            注入普通属性

AOP(面向切面编程):

        概念：是通过预编译和运行期动态代理实现程序功能的统一维护的一种技术

AOP作用：

         在程序运行期间，在不修改源码的情况下对方法进行功能增强

AOP优势：

        减少重复代码，提高开发效率，并便于维护

AOP的底层实现：

        是通过spring提供的动态代理技术实现的。在运行期间，spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

动态代理技术：

        jdk代理：基于接口的动态代理技术

        cglib代理：基于父类的动态代理技术

反射的概念：

         指程序可以访问，检测和修改它本身的状态或行为的一种能力，并能根据自身行为的状态和结果，调整和修改应用所描述行为的状态和相关的语义。

反射机制的的作用：

         1.反编译：.class-->.java

         2.通过反射机制访问java对象的属性，方法，构造方法等。

AOP相关概念：

        Target（目标对象）：代理的目标对象

        Proxy(代理):一个类被AOP织入增强后,就产生一个结果代理类。

        Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,  这些点指的是方法,因为spring只支持方法类型的连接点

        Paintaut(切入点):称谓切入点是指我们要对哪些 Joinpoint进行拦截的定义

        Advice(通知/增强):通知是指拦截到joinpoint之后所要做的事情就是通知

        Aspect(切面):是切入点和通知的结合.

        Weating(织入):是指把增强应用到目标对象来创建新的代理对象的过程。 Spring 采用动态代理识入,而Aspect采用编译期教入类装载期织入。

切点表达式： 

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

静态代理的好处:

• 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
• 公共的业务由代理来完成 . 实现了业务的分工 ,
• 公共业务发生扩展时变得更加集中和方便 .

缺点 :

• 类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

10.2.静态代理再理解

同学们练习完毕后，我们再来举一个例子，巩固大家的学习！

练习步骤：

1、创建一个抽象角色，比如咋们平时做的用户业务，抽象起来就是增删改查！

//抽象角色：增删改查业务
public interface UserService {
   void add();
   void delete();
   void update();
   void query();
}

2、我们需要一个真实对象来完成这些增删改查操作

//真实对象，完成增删改查操作的人
public class UserServiceImpl implements UserService {

   public void add() {
       System.out.println("增加了一个用户");
  }

   public void delete() {
       System.out.println("删除了一个用户");
  }

   public void update() {
       System.out.println("更新了一个用户");
  }

   public void query() {
       System.out.println("查询了一个用户");
  }
}

3、需求来了，现在我们需要增加一个日志功能，怎么实现！

• 思路1 ：在实现类上增加代码 【麻烦！】
• 思路2：使用代理来做，能够不改变原来的业务情况下，实现此功能就是最好的了！

4、设置一个代理类来处理日志！代理角色

//代理角色，在这里面增加日志的实现
public class UserServiceProxy implements UserService {
   private UserServiceImpl userService;

   public void setUserService(UserServiceImpl userService) {
       this.userService = userService;
  }

   public void add() {
       log("add");
       userService.add();
  }

   public void delete() {
       log("delete");
       userService.delete();
  }

   public void update() {
       log("update");
       userService.update();
  }

   public void query() {
       log("query");
       userService.query();
  }

   public void log(String msg){
       System.out.println("执行了"+msg+"方法");
  }

}

5、测试访问类：

public class Client {
   public static void main(String[] args) {
       //真实业务
       UserServiceImpl userService = new UserServiceImpl();
       //代理类
       UserServiceProxy proxy = new UserServiceProxy();
       //使用代理类实现日志功能！
       proxy.setUserService(userService);

       proxy.add();
  }