Spring框架学习

Spring框架概述

Spring是Java EE编程领域的一个轻量级开源框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。
Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，
也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。
因此， Spring不仅仅能应用于J2EE应用程序之中， 也可以应用于桌面应用程序以及小应用程序之中。
Spring框架主要由七部分组成，分别是
Spring Core、 Spring AOP、 Spring ORM、 Spring DAO、Spring Context、 Spring Web和 Spring Web MVC。

框架特征

• 轻量——从大小与开销两方面而言Spring都是轻量的。
• 面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。
• 容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。
• 框架——Spring可以将简单的组件配置、组合成为复杂的应用。
• MVC——Spring的作用是整合，但不仅仅限于整合，Spring 框架可以被看做是一个企业解决方案级别的框架。

spring 特点

- 1.方便解耦，简化开发
- 2.AOP编程的支持
- 3.声明式事务的支持
- 4.方便程序的测试
- 5.方便集成各种优秀框架
- 6.降低Java EE API的使用难度
- 7.Java 源码是经典学习范例
1
2
3
4
5
6
7

spring 入门案例

官网
spring当前最新稳定版本：5.3.23

下载地址

1、新建普通的Java项目
2、创建普通的类
3、新建spring配置文件

IoC 控制反转

1、把创建对象的过程交给spring管理
2、容器：（1）BeanFactory （spring 内部使用，不提供开发者,加载配置文件时不创建对象，使用时创建）
（2）ApplicationContext （是BeanFactory的子接口，功能强大，提供开发者API，加载配置文件时创建对象）

3、什么是Bean管理
（1）Spring创建对象
（2）Spring注入属性

IoC实现的两种方式

• 1、xml自动配置

根据指定装配规则（属性名称或者属性类型），
spring自动将匹配的属性值进行注入
autowire (byName(根据名称注入),byType（根据类型注入）)
1
2
3

• 2、基于注解

注解是代码特殊标记
注解可以用在类，方法，属性上面
注解为了简化xml配置

spring 创建对象的注解：

 - @Component(普通组件)
 - @Service（业务层）
 - @Controller（Web层）
 - @Repository（持久层）

1
2
3
4
5
6
7
8
9
10
11

• 基于注解方式实现属性注入

 (1) @Autowired 根据属性类型进行自动装配
 (2) @Qualifier 根据属性名称进行注入
 (3) @Resource 可以根据类型注入，可以根据名称注入
 (4) @Value 注入普通类型属性
1
2
3
4

完全注解开发
创建配置类，替代xml配置文件

@Configuration
@ComponentScan(value = {"com.company"})
public class SpringCofig {

}


AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringCofig.class);
1
2
3
4
5
6
7
8

AOP 面向切面

不修改源代码进行功能增强

Aspect Oriented Programming（AOP）是较为热门的一个话题。AOP，国内大致译作“面向切面编程”。
“面向切面编程”,这样的名字并不是非常容易理解，且容易产生一些误导。有些人认为“OOP/OOD11即将落伍，AOP是新一代软件开发方式”。
Aspect，的确是“方面”的意思。
需要从不同的角度来看待同一个事物。这里的“方面”，指的是事物的外在特性在不同观察角度下的体现。
而在AOP中，Aspect的含义，可能更多的理解为“切面”比较合适。

不通过修改代码的方式，在主干功能上添加新功能。

主要功能

日志记录，性能统计，安全控制，事务处理，异常处理等等。

主要意图

将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，
我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

原理

AOP底层使用动态代理，有两种情况动态代理：

• 第一种，有接口的情况，使用jdk动态代理
  创建接口实现类的代理对象
• 第二种，没有接口的情况，使用cglib动态代理
  创建当前类子类的代理对象
  JDK动态代理：

java.lang.reflect.Proxy
(1) 调用 newProxyInstance方法
方法有三个参数：
1 ClassLoader 类加载器，
2 interfaces 增强方法所在的类，这个类实现的接口，支持多个接口，
3 InvocationHandler 实现这个接口，创建代理对象，写增强方法

jdk动态代理的示例

public static void main(String[] args) {
        Class[] clzz = {UserDao.class};
        UserDao o = (UserDao) Proxy.newProxyInstance(JdkProxy.class.getClassLoader(), clzz, new UserDaoProxy(new UserDaoImpl()));
        int add = o.add(12, 13);
        System.out.println(add);
    }

    class UserDaoProxy implements InvocationHandler{

        private Object obj;
        public UserDaoProxy(Object obj) {
            this.obj = obj;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 之前处理
            System.out.println("方法之前执行" + method.getName());
            System.out.println("args = " + Arrays.toString(args));
            // 被增强的方法执行
            Object invoke = method.invoke(obj, args);
            // 之后处理
            System.out.println("方法之后执行" + obj);
            return invoke;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

AOP术语

1 连接点

类里边哪些方法可以被增强，这些方法称为连接点

2 切入点

实际被真正增强的方法，称为切入点

3 通知（增强）

（1）实际增强的逻辑部分称为通知（增强）
（2）通知类型：前置通知，后置通知，环绕通知，异常通知，最终通知

4 切面

是动作，把通知应用到切入点的过程。

AOP操作

1. Spring框架一般都是基于AspectJ实现AOP操作
   什么是AspectJ？

AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作。

切入点表达式

（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构
execution([权限修饰符] [返回类型][类全路径][方法名称]（[参数列表]）)
1例：
    对com.c.dao.UserService类里边的insert方法进行增强
    execution(* com.c.dao.UserService.insert(...))

2例：
    对com.c.dao.UserService类里边的所有方法进行增强
    execution(* com.c.dao.UserService.*(...))

3例：
对com.c.dao包里边的所有类，类中的所有方法进行增强
execution(* com.c.dao.*.*(...))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 基于AspectJ实现AOP操作

• 基于xml配置文件

<bean id="bookProxy" class="com.c.aop.BookProxy"/>
        <aop:config>
            切入点
          <aop:pointcut id="p" expression="execution(* com.company.aop.Book.buy(..))"/>
          增强类
          <aop:aspect ref="bookProxy">
            前置通知-增强方法
             <aop:before method="before" pointcut-ref="p"/>
          aop:aspect>
        aop:config>
1
2
3
4
5
6
7
8
9
10

• 基于注解方式实现

1、创建类，在类里边定义方法
2、创建增强类，编写增强的逻辑
3、进行通知的配置
    在spring配置文件中，开启注解扫描
    在增强的类上添加注解@Aspect
4、在spring配置文件中开启生成代理对象
    “\<aop:aspectj-autoproxy/>”
5、配置通知
    切入点 @Pointcut(value = "execution(* com.company.aop.Book.buy(..))")
    前置通知@Before(value = "poitCut()")
    环绕通知
    @Around(value = "execution(* com.company.aop.Book.buy(..))")
    public void around(ProceedingJoinPoint point) throws Throwable
1
2
3
4
5
6
7
8
9
10
11
12
13