34-spring（ssm及微服务入门，临时）

感谢你的路过，希望学生的笔记能给你一点微不足道的参考（2/100）
Java基础思维导图，完整Java体系的链接

1. Spring概述

1.1 什么是框架？

框架（Framework）：框（指其约束性）架（指其支撑性），在软件设计中指为解决一个开放性问题而设计的具有一定约束性的支撑结构。在此结构上可以根据具体问题扩展、安插更多的组成部分，从而更迅速和方便地构建完整的解决问题的方案。
   1、框架本身一般不完整到可以解决特定问题
   2、框架天生就是为扩展而设计的
   3、框架里面可以为后续扩展的组件提供很多辅助性、支撑性的方便易用的实用工具（utilities），
也就是说框架时常配套了一些帮助解决某类问题的库（libraries）或工具（tools）。
如何学习框架呢？
   1、知道框架能做什么
   2、学习框架的语法，一般框架完成一个功能需要一定的步骤
   3、框架的内部实现原理（扩展）
   4、尝试实现一个框架（提升）

1.2 Spring是什么

Spring官网 https://spring.io
   Spring 被称为 J2EE 的春天，是一个是分层的 Java SE/EE full-stack 开源的轻量级的 Java 开发框架， 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用 Spring 框架来创建性能好、易于测试、可重用的代码。
   Spring具有控制反转（IoC）和面向切面（AOP）两大核心。Java Spring 框架通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
   Spring 框架不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何 Java 应用都可以从 Spring 中受益。Spring 框架还是一个超级粘合平台，除了自己提供功能外，还提供粘合其他技术和框架的能力。

1.3 Spring的优势

   1、方便解耦，简化开发
   2、方便集成各种优秀框架
   3、降低 Java EE API 的使用难度
   4、方便程序的测试
   5、AOP 编程的支持
   6、声明式事务的支持

1.4 Spring的体系结构

1.4.1 核心容器

   核心容器由 Spring-core，Spring-beans，Spring-context，Spring-context-support和Springexpression（SpEL，Spring 表达式语言，Spring Expression Language）等模块组成
   Spring-core 模块提供了框架的基本组成部分，包括 IoC 和依赖注入功能。
   Spring-beans 模块提供 BeanFactory，工厂模式的微妙实现，它移除了编码式单例的需要，并且可以把配置和依赖从实际编码逻辑中解耦。
   context 模块建立在由 core和 beans 模块的基础上建立起来的，它以一种类似于 JNDI 注册的方式访问对象。Context 模块继承自 Bean 模块，并且添加了国际化（比如，使用资源束）、事件传播、资源加载和透明地创建上下文（比如，通过Servelet 容器）等功能。Context 模块也支持 JavaEE 的功能，比如 EJB、JMX 和远程调用等。ApplicationContext 接口是 Context 模块的焦点。
   Spring-context-support 提供了对第三方集成到 Spring 上下文的支持，比如缓存（EhCache,Guava, JCache）、邮件（JavaMail）、调度（CommonJ, Quartz）、模板引擎（FreeMarker,JasperReports, Velocity）等。
   Spring-expression 模块提供了强大的表达式语言，用于在运行时查询和操作对象图。它是 JSP2.1规范中定义的统一表达式语言的扩展，支持 set 和 get 属性值、属性赋值、方法调用、访问数组集合及索引的内容、逻辑算术运算、命名变量、通过名字从 Spring IoC 容器检索对象，还支持列表的投影、选择以及聚合等。
   它们的完整依赖关系如下图所示：

1.4.2 数据访问/集成

   JDBC 模块提供了 JDBC 抽象层，它消除了冗长的 JDBC 编码和对数据库供应商特定错误代码的解析。
   ORM 模块提供了对流行的对象关系映射 API 的集成，包括 JPA、JDO 和 Hibernate 等。通过此模块可以让这些 ORM 框架和 Spring的其它功能整合，比如前面提及的事务管理。
   OXM 模块提供了对 OXM 实现的支持，比如 JAXB、Castor、XML Beans、JiBX、XStream 等。
   JMS 模块包含生产（produce）和消费（consume）消息的功能。从 Spring 4.1 开始，集成了Spring-messaging 模块。
   事务模块为实现特殊接口类及所有的 POJO 支持编程式和声明式事务管理。

1.4.3 Web

   Web 模块提供面向 web 的基本功能和面向 web 的应用上下文，比如多部分（multipart）文件上传功能、使用 Servlet 监听器初始化 IoC 容器等。它还包括 HTTP 客户端以及 Spring 远程调用中与web 相关的部分。
   Web-MVC 模块为 web 应用提供了模型视图控制（MVC）和 REST Web服务的实现。Spring 的MVC 框架可以使领域模型代码和 web 表单完全地分离，且可以与 Spring 框架的其它所有功能进行集成。
   Web-Socket 模块为 WebSocket-based 提供了支持，而且在 web 应用程序中提供了客户端和服务器端之间通信的两种方式。
   Web-Portlet 模块提供了用于 Portlet 环境的 MVC 实现，并反映了 Spring-webmvc 模块的功能。

1.4.4 其他

   AOP 模块提供了面向方面（切面）的编程实现，允许你定义方法拦截器和切入点对代码进行干净地解耦，从而使实现功能的代码彻底的解耦出来。
   Aspects 模块提供了与 AspectJ 的集成，这是一个功能强大且成熟的面向切面编程（AOP）框架。
   Instrumentation 模块在一定的应用服务器中提供了类 instrumentation 的支持和类加载器的实现。
   Messaging 模块为 STOMP 提供了支持作为在应用程序中 WebSocket 子协议的使用。它也支持一个注解编程模型，它是为了选路和处理来自 WebSocket 客户端的 STOMP 信息。
   测试模块支持对具有 JUnit 或 TestNG 框架的 Spring 组件的测试。

2、Spring核心之IoC控制反转

2.1 IoC的概念

   Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。IoC 是指在程序开发中，实例的创建不再由调用者管理，而是由 Spring 容器创建。Spring 容器会负责控制程序之间的关系，而不是由程序代码直接控制，因此，控制权由程序代码转移到了 Spring 容器中，控制权发生了反转，这就是 Spring 的 IoC 思想。
我的理解：

2.2 Spring入门案例

2.2.1 创建maven项目

创建完毕的目录结构

2.2.2 pom.xml文件添加依赖和插件

<dependencies>
<!--单元测试-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--spring依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.13.RELEASE</version>
</dependency>
</dependencies>
<build>
<plugins>
<!--编译插件-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>

2.2.3 创建一个实体类

package com.kkb.pojo;
/**
* 实体类球队
*/
public class Team {
   
private Integer id;
private String name;
private String location;
public Team() {
   
System.out.println("Team的默认构造方法被调用：id="+id+",name="+name+",
location="+location);
}
}

2.3.4 创建Spring的配置文件application.xml

2.3.5 使用Spring容器创建对象

配置文件中创建对象

<?xml version="1.0" encoding="UTF-8"?>
<!--spring的配置文件
1、beans: 根标签，spring中java的对象成为bean
2、spring-beans.xsd 是约束文件（约束XML文件中能编写哪些标签）-->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--创建对象：声明bean,通知spring要创建哪个类的对象
一个bean标签声明一个对象：
id="自定义的对象名称" ,要求唯一
class="类的完全限定名" 包名+类名，spring底层是反射机制创建对象，所以必须使用类
名
相当于 Team team1=new Team();创建好的对象放入一个集合Map中
例如：springMap.put("team1",new Team());
-->
<bean id="team1" class="com.kkb.pojo.Team"></bean>
</beans>

2.3.6 获取Spring容器

   Spring 提供了两种 IoC 容器，分别为 BeanFactory 和 ApplicationContext.

2.3.6.1 BeanFactory

BeanFactory 是基础类型的 IoC 容器,是一个管理 Bean 的工厂，它主要负责初始化各种 Bean，并调用它们的生命周期方法。
BeanFactory 接口有多个实现类，
最常见的是org.Springframework.beans.factory.xml.XmlBeanFactory，它是根据 XML 配置文件中的定义装配Bean 的。

BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource(Spring配置文件
的名称));

2.3.6.2 ApplicationContext

ApplicationContext 是 BeanFactory 的子接口，也被称为应用上下文。它不仅提供了 BeanFactory 的所有功能，还添加了对 i18n（国际化）、资源访问、事件传播等方面的良好支持。ApplicationContext 接口有两个常用的实现类:

2.6.2.2.1 ClassPathXmlApplicationContext——常用

   该类从类路径 ClassPath 中寻找指定的 XML 配置文件，找到并装载完成 ApplicationContext 的实例化工作
   ApplicationContext applicationContext=new ClassPathXmlApplicationContext(Spring配置文件的名称);

2.6.2.2.2 FileSystemXmlApplicationContext

   ApplicationContext applicationContext = newFileSystemXmlApplicationContext(String configLocation);
   它与 ClassPathXmlApplicationContext 的区别是：在读取 Spring 的配置文件时，FileSystemXmlApplicationContext 不再从类路径中读取配置文件，而是通过参数指定配置文件的位置，它可以获取类路径之外的资源，如“D:\application.xml”。

2.3.7 通过上下文对象获取容器中的对象

package com.kkb.test;
import com.kkb.pojo.Team;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.FileSystemResource;
import java.util.Date;
public class Test1 {
   
@Test
public void test01(){
   
//使用spring容器创建对象
//1、指定spring配置文件的名称
String springConfig="application.xml";
//2、创建spring容器的对象：
//方式1:不推荐，了解
//BeanFactory beanFactory = new XmlBeanFactory(new
FileSystemResource("D:/workspaces/ideaProjects/MySpring/spring01/src/main/resour
ces/application.xml"));
//beanFactory.getBean("team1");//根据ID从IOC容器获取对象
//方式2：applicationContext--常用
ApplicationContext applicationContext=new
ClassPathXmlApplicationContext(springConfig);//这里执行完毕容器中的对象都已经创建完成
//方式3：applicationContext--了解
//ApplicationContext applicationContext2 = new
FileSystemXmlApplicationContext("D:/workspaces/ideaProjects/MySpring/spring01/sr
c/main/resources/application.xml");
//3、获取容器中的对象
Team team1= (Team) applicationContext.getBean("team1");
//4、容器其他api
int beanDefinitionCount = applicationContext.getBeanDefinitionCount();
System.out.println("spring容器中对象的个数："+beanDefinitionCount);
String[] beanDefinitionNames =
applicationContext.getBeanDefinitionNames();
System.out.println("spring容器中所有对象的名称：");
for (String name : beanDefinitionNames) {
   
System.out.println(name);
}
}
}

2.3.8 创建非自定义对象

pox.xml文件中补充

<!--创建非自定义的对象-->
<bean id="date" class="java.util.Date"></bean>

上面的测试方法中添加如下内容：

//5、获取日期对象
Date date1= (Date) applicationContext.getBean("date1");
System.out.println("日期："+date1);

2.3.9 bean标签的属性

示例演示：
Team实体类补充如下方法：

public void init(){
   
System.out.println("Team ---- init()");
}
public void destroy(){
   
System.out.println("Team ---- destroy()");
}

application.xml配置文件添加如下内容：

<!--
bean标签的属性:
id="自定义的对象名称" ,要求唯一
name="bean对于的一个标识“，一般使用id居多
class="类的完全限定名"
scope="singleton/prototype" 单例/多例
singleton：默认值，单例：在容器启动的时候就已经创建了对象，而且整个容器只有为一个
的一个对象
prototype：多例，在使用对象的时候才创建对象，每次使用都创建新的对象
lazy-init="true/false" 是否延迟创建对象，只针对单例有效
true:不延迟创建对象，容器加载的时候立即创建
false:默认加载，使用对象的时候才去创建对象
init-method="创建对象之后执行的初始化方法"
destroy-method="对象销毁方法，调用容器destroy方法的时候执行"
-->
<bean id="team2" class="com.kkb.pojo.Team" scope="singleton" lazyinit="true" init-method="init" destroy-method="destroy"/>
<bean id="team3" class="com.kkb.pojo.Team" scope="prototype" />

@Test
public void test02(){
   
String springConfig="application.xml";
ClassPathXmlApplicationContext applicationContext=new
ClassPathXmlApplicationContext(springConfig);
Team team1 = (Team) applicationContext.getBean("team1");
Team team11 = (Team) applicationContext.getBean("team1");
System.out.println(team1);
System.out.println(team11);
Team team2 = (Team) applicationContext.getBean("team2");
Team team22 = (Team) applicationContext.getBean("team2");
System.out.println(team2);
System.out.println(team22);
applicationContext.close();//关闭容器
}

2.3 Spring容器创建对象的方式

2.3.1 使用默认的构造方法

2.3.2 使用带参数的构造方法

2.3.3 使用工厂类

三种方式的案例如下：
Team.java类中添加带参数构造方法：

public Team(Integer id, String name, String location) {
   
this.id = id;
this.name = name;
this.location = location;
System.out.println("Team - 带参数的构造方法
id="+id+",name="+name+",location="+location);
}

创建工厂类：

package com.kbb.pojo;
public class MyFactory {
   
/**
* 实例方法
* @return
*/
public Team instanceFun(){
   
System.out.println("MyFactory------instanceFun");
return new Team(1003,"湖人","洛杉矶");
}
/**
* 静态方法
* @return
*/
public static Team staticFun(){
   
System.out.println("MyFactory------staticFun");
return new Team(1004,"小牛","达拉斯");
}
public static void main(String[] args) {
   
Team team1 = MyFactory.staticFun();
MyFactory factory=new MyFactory();
Team team = factory.instanceFun();
}
}

创建新的配置文件createType.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--spring容器创建对象的方式：
1、通过默认构造方法
测试类：
测试结果：
2、通过带参数的构造方法
3、通过工厂方法：实例方法，静态方法-->
<!--1、通过默认构造方法-->
<bean id="team1" class="com.kbb.pojo.Team"></bean>
<!-- 2、通过带参数的构造方法-->
<bean id="team2" class="com.kbb.pojo.Team">
<!--name:表示参数的名称-->
<constructor-arg name="id" value="1001"/>
<constructor-arg name="name" value="勇士"/>
<constructor-arg name="location" value="金州"/>
</bean>
<bean id="team3" class="com.kbb.pojo.Team">
<!--index:表示参数的下标索引-->
<constructor-arg index="0" value="1002"/>
<constructor-arg index="1" value="热火"/>
<constructor-arg index="2" value="迈阿密"/>
</bean>
<!--3、通过工厂方法：
3.1 静态方法
Team team1 = MyFactory.staticFun();-->
<bean id="staticTeam" class="com.kbb.pojo.MyFactory" factorymethod="staticFun"></bean>
<!--3、通过工厂方法：
3.2 实例方法
MyFactory factory=new MyFactory();
Team team = factory.instanceFun();-->
<bean id="factory" class="com.kbb.pojo.MyFactory"></bean>
<bean id="instanceTeam" factory-bean="factory" factory-method="instanceFun">
</bean>
</beans>

测试类：

package com.kkb.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class CreateTypeTest {
   
@Test
public void test01(){
   
ApplicationContext ac=new
ClassPathXmlApplicationContext("createType.xml");
}
}

测试结果：

2.4 基于XML的DI

   DI—Dependency Injection，即“依赖注入”：是组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。
   IoC 是一个概念，是一种思想，其实现方式多种多样。依赖注入就是其中用的比较多的一种方式。Ioc和DI是同一个概念的不同角度描述。IoC是一种思想，概念，DI是实现它的手段。Spring框架使用依赖注入实现IoC.
   Spring 容器是一个超级大工厂，负责创建、管理所有的 Java 对象，这些 Java 对象被称为 Bean。Spring 容器管理着容器中 Bean 之间的依赖关系，Spring 使用“依赖注入”的方式来管理 Bean 之间的依赖关系。使用 IoC 实现对象之间的解耦和。

2.4.1 注入分类

   bean 实例在调用无参构造器创建对象后，就要对 bean 对象的属性进行初始化。初始化是由容器自动完成的，称为注入。

2.4.1.1 通过set方法

   set 注入也叫设值注入是指，通过 setter 方法传入被调用者的实例。这种注入方式简单、直观，因而在Spring 的依赖注入中大量使用。

2.4.1.2 通过构造方法

   构造注入是指，在构造调用者实例的同时，完成被调用者的实例化。使用构造器设置依赖关系。

2.4.1.3. 自动注入

   对于引用类型属性的注入，也可不在配置文件中显示的注入。可以通过为标签设置 autowire 属性值，为引用类型属性进行隐式自动注入（默认是不自动注入引用类型属 性）。根据自动注入判断标准的不同，可以分为两种：
byName：根据名称自动注入
byType： 根据类型自动注入
1、 byName
当配置文件中被调用者 bean 的 id 值与代码中调用者 bean 类的属性名相同时，可使用byName 方式，让容器自动将被调用者 bean 注入给调用者 bean。容器是通过调用者的 bean类的属性名与配置文件的被调用者 bean 的 id 进行比较而实现自动注入的。
2、 byType
使用 byType 方式自动注入，要求：配置文件中被调用者 bean 的 class 属性指定的类，要与代码中调用者 bean 类的某引用类型属性类型同源。即要么相同，要么有 is-a 关系（子类，或是实现类）。但这样
的同源的被调用 bean 只能有一个。多于一个，容器就不知该匹配哪一个了。
示例：
创建TeamDao.java

package com.kkb.dao;
public class TeamDao {
   
public void add(){
   
System.out.println("TeamDao---- add----");
}
}

创建TeamService.java

package com.kkb.service;
import com.kkb.dao.TeamDao;
public class TeamService {
   
private TeamDao teamDao;//=new TeamDao();
public void add(){
   
teamDao.add();
System.out.println("TeamService----add----");
}
public TeamService() {
   
}
public TeamService(TeamDao teamDao) {
   
this.teamDao = teamDao;
}
public TeamDao getTeamDao() {
   
return teamDao;
}
public void setTeamDao(TeamDao teamDao) {
   
this.teamDao = teamDao;
}
}

创建配置文件DI.xml

<?xml version="1.0" encoding="UTF-8"?>