Spring框架

Spring是什么

Spring框架是一个轻量级的解决方案，它是构建企业级应用程序的一个潜在的一站式服务。然而，Spring是模块化的，允许您只使用需要的部分，而不用其他的操作

主要模块

1、IOC:控制反转，创建对象

2、Aop:Spring对象面向切面编程的具体实现，动态代理

3、SpEl:Spring专门为配置文件或java代码准备的表达式

4、JDBC:Spring对JDBC的二次封装

5、tx:声明式事物，编程式事务和声明式事务

6、ORM支持:Spring完美支持，ORM框架

7、mvc:显示层的MVC的实现

优点

1、实现解耦操作:简单的说就是代码之间的嵌套性降低很多，更新版本，只需要更新某一个框架就可以了

2、统一管理对象的生命周期：IOC的作用(适合不频繁改变的对象)

3、配置化实现功能的添加

4、让模块更加的独立：每个模块都可以用Spring拆开，彼此各不影响。

DI

Dependency Injection：依赖注入

就是一个类中的属性是另一个类的对象，并通过方法实现对象的赋值

通过构造方法或setter方法实现对象的实例化过程就是DI

IOC

Inversion of Control:控制反转。

就是创建类的对象的容器，借助依赖注入实现的反转控制。

其实就是借助反射实现指定对象的创建然后通过DI实现属性内容的注入的容器就称为IOC容器。

优点：1、解耦：比如我们之前为属性赋值，只能在代码中，现在可以通过配置文件实现属性内容

2、控制对象的生命周期

通俗的说法：以后的对象我们可以不用new啦，而是可以通过配置使用IOC容器实现对象的创建

Spring的基本使用

使用步骤：

1、引用jar包

2、创建配置文件

3、创建bean类

4、配置添加需要IOC控制的对象

5、使用ApplicationContext

1、创建上下文对象

2、获取指定id或name的对象

Spring配置详解

beans:约束文件，需要哪个模块就在此配置哪个

bean:IOC容器创建的对象

常用属性：

1、id/name:bean标签的唯一标记

2、class:必须，要创建的对象的类全称

3、scope:对象的创建方式

取值：

1、singleton：单例，在整个ApplicationContext对象中就一个,会维护对象的生命周期

2、protortype:多例，每次调用getBean就新建对象，不会维护对象的生命周期

3、request:将创建的对象存储在HttpServletRequest的setAttribute中

4、session:将创建的对象存储在HttpSession中

5、globalSession:在Prolet环境中，使用，非Prolet中，等价与session

4、factory-bean:工厂类的id或name名称

5、factory-method:工厂类的方法，如果是静态方法直接class:工厂类

实例方法，那么需要配置factory-bean

6、lazy-init：是否开启懒加载，默认false,针对singleton

7、init-method:第一次执行的方法

8、destroy-method：最后执行的方法

Spring加载多配置

一般大型项目的xml配置实现的时候可能会根据功能划分配置文件

Spring创建对象的三种方式

1、直接调用构造方法

就是直接配置bean对象

2、静态工厂

创建一个类，静态方法创建需要的类的对象

<bean id="user2" class="com.qf.factory.UserFactory" factory-method="create"></bean>

3、实例工厂

创建一个类，实例方法创建需要的类的对象

<bean id="factory" class="com.tf.factory.NoStaticFactory"></bean>

<bean id="user3" factory-bean="factory" factory-method="createUser"></bean>

Spring为属性赋值的三种方式

1、借助于属性的setXXXX

<property name="id" value="1"></property>

name:属性名称

value:值

2、借助于构造方法

一般都是有参构造，标记的为参数名称

<constructor-arg name="n" value="lisi"></constructor-arg>

index:参数的索引，从0开始

name:参数名称

value:值

对应的构造方法必须存在

3、工厂模式

就是在静态工厂或实例工厂调用对应的有参构造或属性的setXXX

Spring中的懒加载

1.对象的懒加载

bean中的属性lazy-init

默认为false

就是针对scope为singleton的对象，在配置初始化时，是否要创建单例对象

true：就不创建，第一次调用getBean时创建实例

false:配置只要加载就完成对象的实例

2.如果懒加载开启，可能不会发现配置文件初始错误

初始化和销毁方法

init-method：初始化，其实就是对象创建结束(对象构建并且属性赋值)，就调用初始化

destroy-method：销毁，其实就是当ApplicationContext对象关闭或销毁时，依次调用内部的销毁方法，但是对象什么被真正的销毁不知道，一般用在数据库、IO流、Scokect等

SpEL表达式

概念：SpEL:Spring Expression Language:Spring的表达式

就是Spring开发的一种用在java语言的EL表达式，主要用在xml配置中和注解@Value中

作用：

1、写表达式，算术表达式或boolean表达式

比如一个数值比较大，100M:100*1204*1024

2、获取其他bean对象的信息

对象、属性值、方法

3、方法调用

字符串方法、静态方法、实例方法

格式：#{表达式}

语法：

1、数据类型的使用

对数据类型的支持

整型、浮点型、字符串(需要加单引号)、自定义类型(id或name名称)

1、合属性的注入方式

1）直接在属性中嵌套集合

在<property>使用list\set\map\array等

2）使用util中的集合，进行关联

<util:xxx id>

ref引用

3）使用SpEL表达式

引用别的对象的集合属性

引用util:xxx的集合对象

2、运算符的使用

算术运算符：+-*/%

字符串连接运算符：+

比较运算符：>= == != gt(>) ge(>=) lt(<) le(<=) eq(==)

三目运算符：X?Y:Z

三目简写：主要是下面的情况：

#{id.name!=null?id.name:''}

简写：#{id.name?:''}

3、matches正则的支持

使用：带校验的字符串 matches '正则语法'：返回值boolean

4、类的方法和属性的使用

静态调用：

静态属性:#{T(包名.类名).静态属性名}

静态方法:#{T(包名.类名).静态方法([实际参数])}

实例调用：对象属性、对象方法

想调用实例属性或方法时，需要在xml中配置bean标签

对象属性：bean标签的id或name.属性名

对象方法：bean标签的id或name.方法名([实际参数])

5、集合的使用

1、集合属性的注入方式

1）直接在属性中嵌套集合

在<property>使用list\set\map\array等

2）使用util中的集合，进行关联

<util:xxx id>

ref引用

3）使用SpEL表达式

引用别的对象的集合属性

引用util:xxx的集合对象

2、SpEL对集合的操作：集合投影

主要就是提供了对集合的查询操作，三种

1）获取满足条件的第一个元素

格式：#{集合的id.^[条件]}

找不到返回null

实例：#{emp_2.^[age<50]}

转换代码：

for(int i=0;i<list.size();i++){

if(list.get(i).age<50) {

return list.get(i);

}

}

2）获取满足条件的最后一个元素

格式：#{集合的id.$[条件]}

实例：#{emp_2.$[age<50]}

转换代码：

for(int i=list.size()-1;i>=0;i--){

if(list.get(i).age<50){

return list.get(i);

}

}

3）获取符合条件的集合对象

格式：#{集合的id.?[条件]}

实例：#{emp_2.?[age>30]}

转换代码：

List<Emp> desc=new ArrayList<Emp>();

for(int i=0;i<list.size();i++){

if(list.get(i).age>30){

desc.add(list.get(i));

}

}

return desc;

在java代码中使用SpEL表达式:

1、创建解析器对象

SpelExpressionParser //Spel的解析器

2、编写SpEL表达式内容

String el="3*4";

3、解析SpEl表达式

Expression Expression expression=parser.parseExpression("3*4");=parser.parseExpression(el);

4、获取解析结果

expression.getValue();

类中有依赖对象实现注入

1、嵌套bean

直接在<property>内部使用<bean>

2、引用bean对象

在<property>使用ref进行引用

3、使用SpEL引用bean对象

在<property>中的value中使用SpEL：#{}

代理模式

概念

就是2个对象操作时不直接进行交流而是通过代理进行

涉及到的角色：

1、目标类

2、代理类---产生联系的方法

3、行为---方法

分类

静态代理

目标类发生变化，代理类也得跟着变化

实现的2种方式：

1、基于接口：实现

2、基于类：继承

实现步骤：

1、创建接口(行为)

2、创建目标类

3、创建代理类

4、执行方法

动态代理

根据指定的目标类实时生成代理类并返回代理对象来执行方法

jdk

java原生支持的，要求目标类和代理类必须实现相同的接口，实现类代理

1）创建接口

2）创建目标类

3）创建代理工厂

3.1、创建类

3.2、实现接口InvocationHandler

实现接口中的方法：invoke

参数说明：

3.2.1、代理类的对象

3.2.2、当前要执行的方法

3.2.3、方法的实际参数

返回值：就是要执行的方法的返回值

3.3、声明目标类对象并实现注入

3.4、创建方法生成代理类对象

3.5、重新invoke方法进行目标方法的调用

4）生成代理对象

Proxy.newProxyInstance:生成代理类和代理对象

需要三个参数：

4.1、类的加载器，加载动态生成的类信息：ClassLoader:类生成时需要加载

4.2、代理类需要实现的接口：目标类的接口---拥有目标类的Class

4.3、代理类中的方法的回调接口:InvocationHandler:接口

5）调用

cglib

1、如果目标类没有实现接口，那么想使用动态代理，可以选择cglib，子类代理类

2、使用

1）创建目标类

2）创建代理工厂

3）实现拦截接口

实现拦截方法：intercept

参数说明：

1、生成的代理类对象

2、要执行的方法对象

3、实际参数对象

4、要执行的方法的代理对象

返回值：就是执行的方法的返回值

4）声明目标类并实现注入

5）创建生成代理对象的方法

1、创建cglib创建代理类的核心对象

Enhancer

2、设置代理的父类

3、设置回调函数，也就是我们的增强方法

4、生成代理对象

Spring的AOP

概念：

Aspect Oriented Programming:面向切面编程

我们可以不关心类的组成，只需关心类中哪些匹配的方法，这些匹配的方法的增强处理就可以

AOP:就是可以在不改变源码的情况下修改方法

核心：

AOP的核心概念：

1、Aspect：切面

就是匹配的所有的方法的集合

2、Join point：连接点

这就是匹配的每个方法

3、Advice：通知

这就是我们需要增强的代码

4、Pointcut:切入点

获取面的匹配表达式，就是执行通知的时机

5、Introduction：引用

就是将通知起作用

6、Target object:目标类

对哪些类需要做切面编程

7、AOP proxy：代理类

就是根据目标和切面创建代理：jdk或cglib

8、Weaving:织入，编织

创建代理对象的过程

作用：

Spring AOP:作用

就是为一些匹配的方法进行增强处理

对于匹配的方法创建一个公共模块，对此公共模块进行代理操作

经典使用：事物、日志、统计次数、性能等

使用步骤：

1、引用jar包

2、创建目标类

3、创建通知类

4、配置

1、配置自定义通知

2、配置切面信息

1、切入点

2、切面：连接通知

3、配置通知

在什么时候执行什么样的方法

AOP通知类型：

1、<aop:before>:在执行真正的方法执行：前通知

2、<aop:after>:在执行真正的方法之后执行:后通知

3、<aop:around>:在开启之前执行，执行之后再次执行:环绕通知

4、<aop:after-returning>:执行真正的方法，无异常之后执行：成功通知

5、<aop:after-throwing>:执行真正的方法，出现异常之后执行：失败通知

Spring的JDBC

1、JdbcDaoSupport：Dao的支持

2、需要为属性：dataSource赋值

3、Spring为JDBC的操作封装一套框架也就是Spring JDBC

4、使用步骤

1、引用jar包

2、编写数据库就的配置文件

3、编写Spring的配置文件

需要标记DataSource的创建

可以选择C3P0也可以DBCP

4、写Dao层继承JdbcDaoSupport

封装的属性：jdbcTemplate

就包含了数据库的操作

Spring的事务

编程式事务：在代码中使用事务模块

TransactionTemplate:事务模板

声明式事务：可以通过配置实现事务，借助AOP

1、基于xml——》使用aop实现

2、基于注解

Spring的ORM的使用

Spring+Hibernate

Spring的注解

Spring支持注解开发

注解想要起作用，必须在配置开启

<context:component-scan base-package="com.qf"/>

实现IOC

1、@Component

标记类为一个IOC容器需要创建

衍生出来一下三个注解用在不同的包中

@Repository//一般用户持久层的类上--dao

@Service//一般用户业务逻辑层的类上--service

@Controller//一般用于MVC的C层的类上--controller

2、@Scope

标记当前类的代理类怎么创建并且可以标记对象的实例方式

常用属性：

1、scopeName：实例方式

取值：

singleton:单例----只是在当前的ApplicationContext中唯一

prototype:多例，只要调用就创建

request:创建的对象存储到request

session：创建对象存储到HttpSession中

2、proxyMode:代理模式

取值：

ScopedProxyMode.DEFAULT:默认，会根据目标类是否有接口来决定

ScopedProxyMode.NO:不使用代理

ScopedProxyMode.INTERFACES:使用JDK

ScopedProxyMode.TARGET_CLASS:使用CGLIB

3、@Resource

实现对属性的注入,主要是引用bean对象

常用属性：

name:bean的id或name名称

4、@Autowired

实现对属性的注入，只能通过数据类型实现注入，可以结合@Qualifier实现通过bean的id或name注入

5、@Value

直接为属性赋值

注解使用SpEL表达式

1、@Value

值支持SpEL表达式

格式：

@Value("#{表达式}")

单元测试的注解

1、@ContextConfiguration

加载Spring的配置文件

value的值：classpath:applicationContext.xml

2、@RunWith

运行时的测试类

SpringJUnit4ClassRunner.class

AOP的注解

1、@Aspect

标记这是一切面也就是我们自定义通知类

2、@Pointcut

切入点,修饰方法，方法名就是切入点的id名称

常用属性：

value:表达式：execution(* 包.类.方法(..))

3、@Before

前置通知，需要指明切入点

4、@After

后置通知，需要指明切入点

5、@Around

环绕通知，注意参数：就是连接点，就是要执行的方法对象

6、@AfterReturning

成功通知，需要指明切入点

7、@AfterThrowing

失败通知，需要指明切入点

事务注解

1、@Transactional

声明式事务的注解实现

可以修饰类或方法

修改类：该类中所有公共方法开启事务和关闭事务

常用属性：

propagation：事务的传播行为

isolation:事务的隔离级别