Spring入门笔记简要

总览：https://www.processon.com/view/link/605b14ab5653bb2225e6b0c5

一、Spring

1、概述

1、spring框架简介

​ 为简化企业级开发而生，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。

2、优点

​ 轻量、AOP支持、支持对各种框架的集成

3、体系结构

1、数据访问

2、Web开发

3、AOP

4、集成消息等

5、核心容器 IOC

2、IOC控制反转

​ ioc（Inversion of Control）是一种设计思想，把对象的创建、赋值、管理工作都交给代码之外的容器实现，也就是对象的创建是有其他外部资源完成。

**控制：**创建对象，对象赋值，对象之间的关系管理

**反转：**把原来开发人员管理、创建对象的权限转交给代码之外的容器实现，由容器代替开发人员管理对象，创建、赋值等

正转：由开发人员在代码中，使用new构造方法创建对象，开发人员主动管理对象‘；

容器：是一个服务器软件(Tomcat)，一个框架(spring)等

目的：

减少对代码的改动，也能实现不同的功能，实现解耦合

所以：java中创建对象的方式：

1、new

2、反射，class的newInstance()方法，constructor的newInstance()方法

3、反序列化

4、克隆

5、ioc

ioc的技术实现：

​ DI 是 ioc 的技术实现

​ DI （Dependency Injection）依赖注入：只需要在程序中提供使用的对象名称就可以，至于对象如何在容器中创建、赋值、查找都由容器内部实现。

spring是使用的 DI 实现了 ioc 的功能，spring底层创建对象，使用的是反射机制。

2.1 由spring创建对象

实现步骤：

1. 创建maven项目

2. 加入maven依赖

   ​ spring依赖、junit依赖

3. 创建类（接口和他的实现类）

   ​ 和没有使用框架一样，就是普通类

4. 创建spring需要使用的配置文件

   ​ 声明类的信息，由spring创建和管理

仅限于初学的写法：

2.2 DI（依赖注入）的实现方式：

1、基于xml配置文件：在Spring配置文件中，使用标签和属性完成

2、基于注解的实现：使用spring中的注解，完成属性赋值

2.2.1 基于xml配置文件

​ 适合经常需要修改

DI的语法分类：

1、 注入(set设值， 注入就是赋值)：spring调用类的set方法，在set方法中实现属性的赋值（最常用）

2、构造注入，spring调用类的有参构造方法，创建对象，在构造方法中完成赋值

set注入：

1. 简单类型的set注入：

property设值时name属性必须在相应的类中有set方法，且有set方法没有相应的变量也不会报错

​ 2.引用类型的set注入：

​ 引用类型的自动注入：

​ 1、byName：java类中引用类型的属性名和spring容器中（配置文件）的id名称一样，且数据类型一致，这样的容器中的bean，spring能够赋值给引用类型

<bean id="xx" class="yy" autowire="byName"></bean>

让Student类中所有的引用类型都按照byName规则完成赋值

​ 2、byType（按类型注入）：java类中引用类型的数据类型和spring容器中(配置文件)的class属性是同源关系的，这样的bean能够赋值给引用类型

​ 同源：1、java类中引用类型的数据类型和bean中的class值一样

​ 2、java类中引用类型的数据类型和bean中的class值父子类关系的

​ 3、java类中引用类型的数据类型和bean中的class值接口和实现类关系的

​ 注：只能有一个符合条件的，多个会报错

​ class是Student类中引用的School的值：

构造注入

name属性实现构造注入

index属性实现

可以省略index=“”，但是必须按照参数的定义顺序书写

多配置文件优势：

1. 每个文件的大小比一个文件小很多，效率高

2. 避免多人竞争带来的冲突

   按文件的分配方式：

3. 按功能模块，一个模块一个配置文件

4. 按类的功能，数据库相关的配置一个配置文件，做事务的功能一个配置文件，做service功能的一个配置文件

2.2.2 基于注解的实现

​ 快捷，方便，适合不经常修改的

实现步骤：

1. 加入maven依赖spring-context（间接加入了spring-aop依赖）

2. 创建类，在类中加入spring 注解@Component(value=“xxx”)，省略value=也可以（常用），如果只写@Component则会默认value=首字母小写的类名

   

   还有
   @Repository（用在持久层）：放在dao的实现类，表示创建dao对象，dao对象是能访问数据库的
   @Service（用在业务层）：service对象是做业务处理，可以有事务等功能的
   @Controller（用在控制器上）：放在控制器（处理器）类的上面，创建控制器对象的，控制器对象能够接受用户提交的参数，显示请求的处理结果
   以上三个适用语法和@Component一样，都能创建对象，但是他们三个还有额外的功能

   引用类型-@Autowired

   

   引用类型@Resource

   

   ​

3. 在spring配置文件中，加入一个组件扫描器的标签，说明注解在项目中的位置

   

   需要指定多个包时：

   

3、AOP面向切面编程

3.1 动态代理

​ 动态代理能创建对象，在原有类代码不变的情况下，实现功能的增加，功能增强。

3.1.1 JDK 动态代理

​ 要求目标对象必须实现接口，java语言通过java.lang.reflect包提供三个类支持代理模式Proxy，Method和InvcationHandler，要求目标类和方法不能是final的，因为final不能被继承，不能被重写啊

​ 实现步骤:

1. 创建目标类，SomeserviceImpl目标类，给它的doSome，dother增加输出时间，事务。

2. 创建InvocationHandler接口的实现类，在这个类实现给目标方法增加功能。

   

3. 使用jdk中类Proxy ,创建代理对象。实现创建对象的能力。

   

作用：

1. 在目标类源码不改变的情况下，增加功能

2. 减少代码的重复

3. 专注业务代码逻辑

4. 解耦合，让业务与日志扥，事务非业务功能分离

3.1.2 CGLB动态代理（了解）

​ CDLIB（Code Generation Library）是一个开源项目，原理是生成目标类的子类，子类是代理对象。

3.2 AOP简介

​ AOP（Aspect Orient Programming） 面向切面编程，底层的实现就是采用动态代理模式实现的，采用了JDK的动态代理和CGLIB的动态代理。

​ Aspect：切面，给目标类增加的功能

​ 特点：一般都是非业务方法，独立使用的

如何理解AOP：

​ 以切面为核心，围绕切面来开发程序：

​ 1）分析项目功能时找到切面

​ 2）合理安排执行时间，（在目标方法前还是后）

​ 3）合理的安排切面执行的位置， 在哪个类，哪个方法增加增强功能

3.3 AOP编程术语

1. AOP：切面，表示增强的功能，就是一堆代码，完成某一个功能，非业务功能

   ​ 常见的切面功能有日志，事务，统计信息，参数检查，权限验证

2. JoinPoint：连接点，连接业务方法和切面的位置，就是某类中的业务方法

3. PointCut：切入点，指多个连接方法的集合，多个方法

4. 目标对象：给哪个类的方法这个价功能，这个类就是目标对象

5. Advice：通知，表示切面功能 执行的时间，方法之前还是之后

切面三个关键要素：

1. 切面的功能代码，切面干什么
2. 切面的执行位置，使用PointCut表示切面执行的位置
3. 切面的执行时间，使用Advice表示时间，在目标方法之前还是之后

3.4 AOP的实现

​ AOP是一个规范，是动态的一个规范化，一个标准

​ aop的技术实现框架:

1. spring：spring内部实现了aop的规范，能做aop的工作

   ​ spring在处理事务时使用aop

   ​ 在项目开发中很少使用spring的aop实现，因为spring的aop比较笨重

2. Aspect：一个开源的专门做aop的框架，spring框架中集成了aspectj框架，通过spring就能使用aspectj的功能

   aspectj框架实现aop的两种方式：

   使用xml的配置文件：配置全局事务
3. 使用注解，在项目中要做aop功能，一般使用注解

3.4 AspectJ框架的使用

1. 切面的执行时间，这个执行时间在规范中叫做Advice（通知，增强）

   在aspect框架中使用注解表示，也可以使用xml配置文件中的标签

   <!-- 5个常用注解
   @Before
   @AfterReturning
   @Around
   @After
   @AfterThrowing
   -->

2. 表示切面执行的位置，使用的是切入表达式

   execution（访问权限 方法返回值 方法参数 异常类型）

   在其中可以使用以下符号：
   *	：0至多个任意字符
   ..	： 用在方法参数中，表示任意多个参数；用在包名后，表示当前包及其子包
   +	：用在类名后，表示当前类及其子类；用在接口名后，表示当前接口及其实现类

   指定切入点为：任意公共方法
   execution(public * *(..))
   指定切入点为：任意一个以set开始的方法
   execution(* set*(..))
   指定切入点为：com.mhz.service包中的任意类中的任意方法,不包含子包
   execution(* com.mhz.service.*.*(..))
   指定切入点为：com.mhz.service或者子包包中的任意类中的任意方法
   execution(* com.mhz.service..*.*(..))
   指定切入点为：所有service包下的任意类的任意方法
   execution(* *..service.*.*(..))

使用aspectJ实现aop的基本步骤：

1. 新建maven项目

2. 加入依赖

   spring依赖
3. aspectj依赖
4. junit单元测试（可有可无）

<!--把对象交给spring容器，由spring容器统―创建，管理对象-->
<! --声明目标对象-->
<bean id="someservice" class="com.bjpowernode.bao1.SomeserviceImpl"/>
<! --声明切面类对象-->
<bean id="myAspect" class="com.bjpowernode.ba01.MyAspect”/>
<!--
声明自动代理生成器:使用aspectj框架内部的功能，创建目标对象的代理对象。
创建代理对象是在内存中实现的，修改目标对象的内存中的结构。创建为代理对象所以目标对象就是被修改后的代理对象
aspectj-autoproxy:会把spring容器内的所有目标对象，一次性都生成代理对象
-->
<aop: aspectj-autoproxy />

六个注解：

1、@Before：

前置通知注解
属性: value，是切入点表达式，表示切面的功能执行的位置。
位置:	在方法的上面
特点:
1.在目标方法之前先执行的
2.不会改变目标方法的执行结果
3.不会影响目标方法的执行。

/*
* 指定通知方法中的参数：JoinPoint
* JoinPoint:业务方法，要加入切面功能的业务方法
* 作用是：可以在通知方法中获取方法执行时的信息，例如方法名称，方法的实参。
* 如果你的切面  功能中需要用到方法的信息，就加入JoinPoint.
* 这个JoinPoint参数的值是由框架赋予，必须是第一个位置的参数
*/

@Before(value = "execution(void *..SomeServiceImpl.doSome(String, Integer))")
public void myBefore(JoinPoint jp){
//获取方法的完整定义
system.out.println("方法的签名（定义)="+jp.getsignature());
system.out.println("方法的名称="+jp.getsignature().getName());//获取方法的实参
object args []= jp.getArgs();
for (object arg:args){
system.out.println("参数="+arg);
}
}

2、@AfterReturning：

后置通知定义方法，方法是实现切面功能的。
方法的定义要求:
1.公共方法 public
2.方法没有返回值
3.方法名称自定义
4.方法有参数的,推荐是object,参数名自定义

@AfterReturning:后置通知
属性:
1.value切入点表达式
2.returning自定义的变量，表示目标方法的返回值的。自定义变量名必须和通知方法的形参名一样。
位置:在方法定义的上面
特点:
1. 在目标方法之后执行的。
2. 能够获取到目标方法的返回值，可以根据这个返回值做不同的处理功能
3. 可以修改这个返回值

@AfterReturning(value="execution(* *..SomeServiceImpl.doOther(..))",returning="res")
// 此处returning的res名称=Object的res名称就行
public void myAfterReturing(object res){
// object res:是目标方法执行后的返回值，根据返回值做你的切面的功能处理
// 思考：如果是对类对象res的更改会不会影响在程序执行后得到的输出结果？
system.out.println("后置通知:在目标方法之后执行的，获取的返回值是:"+res);
if(res.equals("abcd"))
{
//做―些功能
}
e1se
{
//做其它功能
}

}

3、@Around

环绕通知
方法的定义格式:
1.public
2.必须有一个返回值，推荐使用object
3.方法名称自定义
4.方法有参数，固定的参数ProceedingjoinPoint

@Around:环绕通知
属性:value切入点表达式位宣:在方法的定义什么
特点:
1.它是功能最强的通知
2.在目标方法的前和后都能增强功能。
3.控制目标方法是否被调用执行
4.修改原来的目标方法的执行结果。影响最后的调用结果

等同于jdk动态代理的，InvocationHandler接口
参数：ProceedingJoinPoint 等同于Method
作用：执行目标方法
返回值：就是目标方法的执行结果，可以被修改

@Around(value = "execution(* *..SomeService1mpl.doFirst(..))")
public object myAround(ProceedingJoinPoint pjp) throws Throwable {
// 获取第一个参数值
Object[] args = pjp.getArgs();
String name = "";
if(args != null && args.length > 1){
Object arg = args[0];
name = (String)arg;
}
//实现环绕通知
object result = null;
system.out.println("环绕通知:在目标方法之前，输出时间:"+ new Date());
//1.目标方法调用
if("xxx".equals(name)){
// 控制是否执行目标方法
result = pjp.proceed(); //method.invoke(); object result = doFirst();
}
system.out.println("环绕通知:在目标方法之后，提交事务");
//2.在目标方法的前或者后加入功能
//返回目标方法的执行结果
return result;
}

4、 @AfterThrowing

异常通知：
1、public
2、没有返回值
3、方法，名称自定义
4、方法有一个Exception，如果还有就是JoinPoint

@AfterThrowing：异常通知
属性：1、value
2、throwing自定义变量，表示目标方法抛出的异常对象，变量名和方法的参数名一样
特点：1、在目标方法抛出异常时执行
2、可以做异常的监控程序，如果有异常，可以发邮件，短信通知等
执行时：
没有异常就走正常逻辑，有异常就走定义的@AfterThrowing注解的方法
try{
SomeServiceImpl.doSecond(..);
}
catch(Exception ex){
myAfterThrowing(ex);
}

@AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",throwing = "ex")
public void myAfterThrowing(Exception ex){
system.out.println("异常通知:方法发生异常时,执行: "+ex.getMessage());//发送邮件，短信，通知开发人员
}

5、@ After

最终通知
方法的定义格式
1.public
2.没有返回值
3.方法名称自定义
4.方法没有参数，如果还有是JoinPoint

@After:最终通知
属性：value 切入点表达式
位置：方法上面
特点：
1、总是执行
2、目标方法后执行，即使抛出了异常
类似于：
try/catch中的finally代码块

@After(value = "execution(* *..SomeserviceImpl.doThird(..))")
public loidmyAfter(){
//一般做资源清除工作的。
systemyout.println("执行最终通知，总是会被执行的代码");
}

6、 @PointCut

定义管理切入点
如果项目中很多个切入点表达式是重复的，，使用@PointCut
属性：value 切入点表达式
位置：方法上面
特点：
当使用@Pointcut定义在一个方法的上面，此时这个方法的名称就是切入点表达式的别名。其它的通知中，value属性就可以使用这个方法名称，代替切入点表达式了

@Pointcut(value = "execution(* *..SomeserviceImpl.doThird(..))”)
private void mypt(){
//无需代码，
}
// 然后：
@Before(value="mypt()")
public void myBefore(){

}

4、Spring事务

4.1 Spring的事务管理

1. 什么是事务？

   ​ 指的是一组sql语句的集合，集合中有多个sql语句，增删查改，希望这些sql语句斗殴成功或者都失败，这些sql 的执行是一致的，作为一个整体执行。

2. 什么时候用到事务？

   ​ 当操作涉及多个表或者多个sql语句的增删改，需要保证这些sql语句都成功才能完成功能，或者都失败，保证操作是符合要求的。

   ​ 在java代码中写程序，控制事务，需要写在service类的业务方法上，因为业务方法汇调用多个dao方法，执行多个sql语句

3. jdbc、Mybatis访问数据库处理事务？

   //jdbc
   Connection conn;
   conn.commit();
   conn.rollback();
   //mybatis
   SqlSession.commit();
   SqlSession.rollback();

4. 问3中处理事务的方式是不同的，所以有哪些不足：

   不同的数据库访问技术，处理事务的对象、方法不同，需要掌握了解不同数据库访问技术使用事务的原理

5. 掌握多种数据库中事务的处理逻辑，提交、回滚等

   多种数据库访问技术，有不同的事务处理的机制，对象、方法