Spring_图解
Spring简介
Spring简介什么是Spring?spring是分层的avaSE以及javaEE应⽤于全栈的轻量级开源框架，以IOC（Inverse Of Control）控制反转,AOP(Aspect Oriented Programing)⾯向切⾯编程为核⼼，提供表现层SpringMVC以及持久层Spring,并且可整合多种其他开源框架。
spring的本质是管理对象，包括创建对象及维护对象之间的关系。
spring的优点1)⽅便解耦，简化开发通过spring的IOC可将对象的创建，以及对象之间的依赖都交由spring容器来进⾏管理，这样可以降低程序之间的耦合。
并且开发时也只需关注上层的应⽤，不⽤再多关注底层的应⽤。
2）AOP编程的⽀持spring⽀持AOP⾯向切⾯编程，许多OOP⾯向对象编程不能或很难实现的功能，都可通过AOP轻松实现。
3）声明式事务的⽀持可以将我们从单调烦闷的事务管理中解放出来，通过声明式事务的⽅式，可以灵活的进⾏事务管理，进⽽提⾼开发的质量和效率。
4）⽅便程序的测试可以⽤⾮容器依赖的编程⽅式进⾏⼏乎所有的测试⼯作，测试不再是昂贵的操作，⽽是随⼿可做的事情。
5）⽅便集成各种优秀的框架Spring可以降低各种框架的使⽤难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接⽀持。
6）降低javaEE的API的使⽤难度Spring对 JavaEE API（如 JDBC、JavaMail、远程调⽤等）进⾏了薄薄的封装层，使这些API 的使⽤难度⼤为降低。
7)spring框架的源码是经典学习的案例Spring的源代码设计精妙、结构清晰、匠⼼独⽤，处处体现着⼤师对Java设计模式灵活运⽤以及对 Java技术的⾼深造诣。
它的源代码⽆疑是Java技术的最佳实践的范例。
通过Spring进⾏解耦什么叫程序的耦合？在程序中，对象之间相互依赖，相互传递数据，这种相互关联的程度越⾼，程序的耦合度就越⾼。
Spring参考手册
第一部分 Spring框架的概述Spring框架是一个轻量级的解决方案和为构建企业级应用程序潜在的一站式服务。
然而，Spring是模块化的，允许你只使用那些你需要的部分，而忽略其他部分。
你可以在使用Struts时用Spring的IoC 容器，但你也可以只使用Hibernate 集成代码或JDBC抽象层。
Spring框架支持声明式事务管理、通过RMI或web服务远程访问你的逻辑,还有多种方式处理数据的持久化。
它还提供一个全能的MVC框架，并且能将AOP移植进你的软件。
Spring被设计为非侵入式的，意味着你的逻辑代码完全不必依赖于此框架。
虽然一些基于数据访问技术和Spring的库会存在于你的集成层（例如数据访问层），但是你的其他代码很容易隔离这些依赖。
1.开始使用Spring这篇手册提供了关于spring框架的详细信息，不仅有全面的特性，还有一些关于spring包含的潜在的概念（例如“依赖注入”）的背景知识。
如果你才刚刚开始，也许你应该从低级版的"Getting Started" 手册开始，从bbb://spring.io.访问。
为了更容易消化，这篇手册是专注于任务式。
2.Spring框架的介绍Spring框架是一个支持开发Java应用程序而提供全面的基础设施的Java平台，Spring处理基础部分从而你可以专注于你的应用。
spring 让你能够通过POJOs和向POJOs应用无侵入的企业服务就可以构建你的应用。
这些不仅能应用到Java SE而且还能应用到Java EE.一些作为一个开发者能够使用spring平台优势的例子●使Java方法可以执行数据库事务而不用去处理事务API●使本地Java方法可以执行远程过程而不用去处理远程API●使本地Java方法可以拥有管理操作而不用去处理JMXAPI●使本地Java方法可以执行消息处理而不用去处理JMSAPI2.1 依赖注入和控制反转Java应用程序——一个宽松的专业术语，小到一个Appletes大到运行在n层服务器上的企业级程序—通常由互相协作的对象而形成的适当的应用程序。
Spring核心技术详解
Spring核⼼技术详解⼀、Sring简介Spring是⼀个分层的Java SE/EE应⽤⼀站式的轻量级开源框架。
Spring核⼼是IOC和AOP。
Spring主要优点包括：⽅便解耦，简化开发，通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进⾏控制，避免硬编码造成的程序耦合度⾼。
AOP编程的⽀持，通过Spring提供的AOP功能，⽅便进⾏⾯向切⾯编程。
声明式事务的⽀持，在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式⽅式灵活地进⾏事务的管理，提⾼开发效率和质量。
⽅便程序的测试，可以⽤⾮容器依赖的编程⽅式进⾏⼏乎所有的测试⼯作。
⽅便集成各种优秀框架，Spring提供了对各种优秀框架的直接⽀持。
⼆、Spring体系结构如下图所⽰，整个spring框架按其所属功能可以划分为五个主要模块，这五个模块⼏乎为企业应⽤提供了所需的⼀切，从持久层、业务层到表现层都拥有相应的⽀持，这就是为什么称Spring是⼀站式框架的原因。
核⼼模块(Core Container) Spring的核⼼模块实现了IoC的功能，它将类和类之间的依赖从代码中脱离出来，⽤配置的⽅式进⾏依赖关系描述。
由IoC容器负责类的创建，管理，获取等。
BeanFactory接⼝是Spring框架的核⼼接⼝，实现了容器很多核⼼的功能。
Context模块构建于核⼼模块之上，扩展了BeanFactory的功能，包括国际化，资源加载，邮件服务，任务调度等多项功能。
ApplicationContext是Context模块的核⼼接⼝。
表达式语⾔(Expression Language)是统⼀表达式语⾔(EL)的⼀个扩展，⽀持设置和获取对象属性，调⽤对象⽅法，操作数组、集合等。
使⽤它可以很⽅便的通过表达式和Spring IoC容器进⾏交互。
AOP模块Spring AOP模块提供了满⾜AOP Alliance规范的实现，还整合了AspectJ这种AOP语⾔级的框架。
图解SpringBoot解析yml全流程
图解SpringBoot解析yml全流程背景前⼏天的时候，项⽬⾥有⼀个需求，需要⼀个开关控制代码中是否执⾏⼀段逻辑，于是理所当然的在yml⽂件中配置了⼀个属性作为开关，再配合nacos就可以随时改变这个值达到我们的⽬的，yml⽂件中是这样写的：switch:turnOn: on程序中的代码也很简单，⼤致的逻辑就是下⾯这样，如果取到的开关字段是on的话，那么就执⾏if判断中的代码，否则就不执⾏：@Value("${switch.turnOn}")private String on;@GetMapping("testn")public void test(){if ("on".equals(on)){//TODO}}但是当代码实际跑起来，有意思的地⽅来了，我们发现判断中的代码⼀直不会被执⾏，直到debug⼀下，才发现这⾥的取到的值居然不是on⽽是true。
看到这，是不是感觉有点意思，⾸先盲猜是在解析yml的过程中把on作为⼀个特殊的值进⾏了处理，于是我⼲脆再多测试了⼏个例⼦，把yml 中的属性扩展到下⾯这些：switch:turnOn: onturnOff: offturnOn2: 'on'turnOff2: 'off'再执⾏⼀下代码，看⼀下映射后的值：可以看到，yml中没有带引号的on和off被转换成了true和false，带引号的则保持了原来的值不发⽣改变。
到这⾥，让我忍不住有点好奇，为什么会发⽣这种现象呢？于是强忍着困意翻了翻源码，硬磕了⼀下SpringBoot加载yml配置⽂件的过程，终于让我看出了点门道，下⾯我们⼀点⼀点细说！因为配置⽂件的加载会涉及到⼀些SpringBoot启动的相关知识，所以如果对这⼀块不是很熟悉的同学，可以先提前先看⼀下Hydra在古早时期写过⼀篇⽂章预热⼀下。
下⾯的介绍中，只会摘出⼀些对加载和解析配置⽂件⽐较重要的步骤进⾏分析，对其他⽆关部分进⾏了省略。
Spring技术内幕：深入解析Spring架构与设计原理
Spring技术内幕深入解析Spring架构与设计原理（一）引子缘起已经很久没有写帖子了，现在总算是有点时间写些东西，也算是对自己的一个记录吧。
刚刚完成了一个软件产品，从概念到运营都弄了一下，正在推广当中，虽然还没有能够达到盈亏平衡，但是这个过程，对自己也算是一种历练。
先不管结果如何，好呆走过这么一遭了。
我打算用这个帖子，把自己在这个过程中的一些心得，特别是对Spring新的理解，记录下来。
使用这个帖子的标题，持续下来。
简单来说，自己的软件产品是一个基于互联网的SaaS协同软件平台,操作简单，支持流程定义，管理和多种客户端 -像短信，MSN，智能手机什么的（我这里就不多做什么广告了），也有一个企业版的版本，使用的技术框架是Hibernate + Spring + Wicket，下面是Linux和MySQL，还有云计算的平台的使用，以支持其扩展性，虽然现在还没有可扩展性的需求，但似乎不难从SaaS上，就会想到云计算, 其实，它们真的是天生的一对！关于云计算，自己对这个技术很感兴趣，觉得和开源软件的结合，是很有意思的，因为它们都有基于服务的基因，在云计算平台的使用上，也有一些初步的实践。
云计算是一个很有意思的话题，但在这里主要是想谈Spring，所以对云计算，这里就先不多说了，但非常欢迎有兴趣的朋友和一起另外找地方讨论！回到正题，在我自己的产品中，其中除了Wicket和云计算外，其他都是大家非常熟知的了，像Hibernate, Spring, MySQL什么的。
在这个过程中，发现自己对一些技术点也有了新的认识，最有体会的是Spring。
当然，在这个过程中，更大的收获是对产品开发整个过程的认识，在这点上，真是一言难尽........回到自己还算了解的Spring, 这次我使用的是3.0的代码，所以，有机会也把这些代码读了几遍，比原来的理解要加深了许多，也发现了不少和2.0代码不同的地方，以及自己一些对 Spring的新的理解，这些，就让我就用这个帖子系列，给自己总结一下，也算是对自己以前的那个代码分析的帖子做一个新的交代吧。
什么是spring框架
什么是spring框架
⼀bai.概念：1. spring是开源的轻量级框架
2 spring核⼼主要两部分：
（1）aop：⾯向切⾯编程，扩展功能不是修改源代码实现
（2）ioc：控制反转，
- ⽐如有⼀个类，在类⾥⾯有⽅法（不是静态的⽅法），调⽤类⾥⾯的⽅法，创建类的对象，使⽤对象调⽤⽅法，创建类对象的过程，需要new出来对象
- 把对象的创建不是通过new⽅式实现，⽽是交给spring配置创建类对象
⼆.好处
我⽤通俗的话给你解释把。
⾸先你不⽤框架不是每次创建对象都要⽤关键字“new”呢？对吧。
有了spring配置就不⽤new了，直接拿。
举个例⼦：假如你吃饭，每次你要吃饭时都要⾃⼰准备碗和筷⼦，每次都要⾃⼰准备，⽤了框架后，再吃饭你只要吃就⾏了，就不⽤准备碗和筷⼦了因为spring已经给你准备好了。
这样是不是很⽅便。
pring主要就是不⽤你⾃⼰创建对象，都配置在配置⽂件中。
如果你写好⼀个项⽬，你再a类中创建了b类的⽅法，c类也创建了b类的⽅法，如果那天要改b类的类名，你就要在a和c中都改，如果有100个类都⽤了b类呢？那你不是要改死哦
如果⽤了spring，你只要修改配置⽂件⼀个位置就好了，是不是很⽅便维护呢。
从零开始搭建springboot+springcloud+mybatis本地项目全过程（图解）
从零开始搭建springboot+springcloud+mybatis本地项⽬全过程（图解）记录⼀下从零开始搭建⼀个springboot+springcloud+mybatis本地项⽬的demo的过程。
纯代码⼩⽩⼀枚，若有不⾜或错误之处，欢迎⼴⼤朋友指出！开发环境准备：IDE：IntelliJ Idea 2019.3数据库：mysql 8.0.2.2SpringBoot版本：2.2.0.RELEASESpringCloud版本：Hoxton.RELEASE⼀、创建⼀个新的Idea项⽬打开Idea，单击New->File->Project，选择Maven，直接下⼀步输⼊我们的项⽬名，我这⾥起名为pam，单击Finish完成创建⼆、右键单击project下的⽗节点->New->Module，创建⼀个注册中⼼服务端的Module，输⼊⼀下名称，我这⾥以pam-server为例，直接选finish；同理再创建⼀个客户端的Module，输⼊⼀下名称，我这⾥以pam-service为例，直接选finish，结构如图所⽰：三、单击File->Settings->Maven，配置⼀下本地的maven，单击OK四、在最外层pom⽂件引⼊⼀下springboot、springcloud及mybatis的依赖。
这⾥引⼊的springboot版本为2.2.0-RELEASE，与之相对应的springcloud版本为Hoxton.RELEASE。
注意⼆者版本需要相适配，否则会启动报错。
这⾥额外引⼊了⼏个常⽤依赖，直接在maven单击⼀下刷新，仓库即可在线将所需依赖下载进去。
<dependencyManagement><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><version>2.2.0.RELEASE</version><type>pom</type><scope>import</scope></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-dependencies</artifactId><version>Hoxton.RELEASE</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement><dependencies><!--注册中⼼相关依赖--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-server</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.0.4.RELEASE</version></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-api</artifactId><version>2.10.0</version></dependency><!--mysql--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.16</version></dependency><!--mybatis--><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.0.0</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-tomcat</artifactId><scope>provided</scope></dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-freemarker</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-logging</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-config</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-eureka-server</artifactId><version>1.3.1.RELEASE</version></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-contract-stub-runner</artifactId><scope>test</scope></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-contract-verifier</artifactId><scope>test</scope></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-stream-test-support</artifactId><scope>test</scope></dependency><dependency><groupId>mons</groupId><artifactId>commons-lang3</artifactId><version>3.5</version></dependency><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>3.0.1</version></dependency><dependency><groupId>commons-lang</groupId><artifactId>commons-lang</artifactId><version>2.6</version></dependency></dependencies>五、创建如图所⽰的⽬录结构：①编写注册中⼼，注册中⼼⽬录结构：编写WebApplication启动类，添加注解@EnableEurekaServer和@SpringBootApplication，我这⾥想做⼀个纯注册中⼼，不与数据库挂钩，所以增加了⼀个exclude = DataSourceAutoConfiguration.class，启动项⽬时不⾃动与数据库连接，若想让注册中⼼也连接数据库，这个exclude也可以不要。
Spring简单实例
Spring 实例入门本文结合实例理解解容器，DI，IOC，耦合，解耦等Spring所涉及的概念，同时了解Spring 的最基本也是最核心的使用方法。
1．Spring容器Spring容器负责对象的实例化，对象生命周期的管理，被Spring管理的对象称之为Bean。
Spring默认使用单例的方式创建对象。
可以通过修改<bean>的配置改变成其它创建方式。
这个属性为Scope，称之为作用域或生命周期，它的值为singleton（单例，默认值），prototype2．注入方式有setter注入，构造注入方式，接口注入（不需掌握）。
建议多使用Setter注入方式。
Setter注入：Soldier类中有一个属性name，如何在创建Soldier的时候使name的值变为”RANBO”?配置如下：这样创建的Soldier对象的name属性就有值了，测试代码：构造注入：配置如下：测试结果同上。
3．依赖当A对象使用了B对象的方法，A对B产生依赖，称之为A依赖B。
下面的例子中Soldier当HandGun发生变化时，必然导致Soldier必须做相应修改，同时，当Soldier需要使用OtherGun时也必须重新编写代码，导致代码重用度不高。
当对象之间的依赖关系很强时（耦合），会使程序代码死板，不利于后期的维护和扩展。
降低对象之间的依赖关系称之为解耦。
Spring能够很好的解决这一问题。
4．控制反转（Inversion of Control,简称IOC）和依赖注入(Dependence Inject简称DI)我们运用Spring的setter注入方式解决HandGun和Soldier的耦合问题。
修改Soldier的代码，将HandGun定义为Soldier的属性并提供setter方法：package com.hb;/***士兵类*/public class Soldier {private HandGun handGun;public void setHandGun(HandGun handGun) {this.handGun = handGun;}/***打仗*/public void fight(){handGun.killEnemy();}}配置如下己去实例化HandGun了。
spring内核详解
Spring作为现在最优秀的框架之一，已被广泛的使用，51CTO也曾经针对Spring框架中的JDBC应用做过报道。
本文将从另外一个视角试图剖析出Spring框架的作者设计Spring框架的骨骼架构的设计理念，有那几个核心组件？为什么需要这些组件？它们又是如何结合在一起构成Spring的骨骼架构？Spring的AOP特性又是如何利用这些基础的骨骼架构来工作的？Spring中又使用了那些设计模式来完成它的这种设计的？它的这种设计理念对对我们以后的软件设计有何启示？本文将详细解答这些问题。
Spring的骨骼架构Spring总共有十几个组件，但是真正核心的组件只有几个，下面是Spring框架的总体架构图：图1.Spring框架的总体架构图从上图中可以看出Spring框架中的核心组件只有三个：Core、Context和Beans。
它们构建起了整个Spring 的骨骼架构。
没有它们就不可能有AOP、Web等上层的特性功能。
下面也将主要从这三个组件入手分析Spring。
Spring的设计理念前面介绍了Spring的三个核心组件，如果再在它们三个中选出核心的话，那就非Beans组件莫属了，为何这样说，其实Spring就是面向Bean的编程（BOP,Bean Oriented Programming），Bean在Spring 中才是真正的主角。
Bean在Spring中作用就像Object对OOP的意义一样，没有对象的概念就像没有面向对象编程，Spring中没有Bean也就没有Spring存在的意义。
就像一次演出舞台都准备好了但是却没有演员一样。
为什么要Bean这种角色Bean或者为何在Spring如此重要，这由Spring框架的设计目标决定，Spring为何如此流行，我们用Spring 的原因是什么，想想你会发现原来Spring解决了一个非常关键的问题他可以让你把对象之间的依赖关系转而用配置文件来管理，也就是他的依赖注入机制。
各技术框架架构图
架构图Spring 是一个开源框架,是为了解决企业应用程序开发复杂性而创建的.框架的主要优势之一就是其分层架构,分层架构允许您选择使用哪一个组件,同时为J2EE 应用程序开发提供集成的框架.Spring 框架的功能可以用在任何J2EE 服务器中,大多数功能也适用于不受管理的环境.Spring 的核心要点是：支持不绑定到特定J2EE 服务的可重用业务和数据访问对象.这样的对象可以在不同J2EE 环境Web或EJB 、独立应用程序、测试环境之间重用.组成Spring 框架的每个模块或组件都可以单独存在,或者与其他一个或多个模块联合实现.每个模块的功能如下：核心容器：核心容器提供Spring 框架的基本功能.核心容器的主要组件是BeanFactory ,它是工厂模式的实现.BeanFactory 使用控制反转 IOC 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开.Spring 上下文：Spring 上下文是一个配置文件,向Spring 框架提供上下文信息.Spring 上下文包括企业服务,例如JNDI 、EJB 、电子邮件、国际化、校验和调度功能.Spring AOP ：通过配置管理特性,Spring AOP 模块直接将面向方面的编程功能集成到了Spring 框架中.所以,可以很容易地使Spring 框架管理的任何对象支持AOP .SpringAOP 模块为基于Spring 的应用程序中的对象提供了事务管理服务.通过使用Spring AOP ,不用依赖EJB 组件,就可以将声明性事务管理集成到应用程序中.Spring DAO ：JDBC DAO 抽象层提供了有意义的异常层次结构,可用该结构来管理异常处理和不同数据库供应商抛出的错误消息.异常层次结构简化了错误处理,并且极大地降低了需要编写的异常代码数量例如打开和关闭连接.Spring DAO 的面向JDBC 的异常遵从通用的DAO 异常层次结构.Spring ORM ：Spring 框架插入了若干个ORM 框架,从而提供了ORM 的对象关系工具,其中包括JDO 、Hibernate 和iBatis SQL Map .所有这些都遵从Spring 的通用事务和DAO 异常层次结构.架构图ibatis 是一个基于Java的持久层框架. iBATIS 提供的持久层框架包括 SQL Maps 和Data Access Objects DAO ,同时还提供一个利用这个框架开发的 JPetStore 实例.IBATIS ：最大的优点是可以有效的控制sql 发送的数目,提高数据层的执行效率它需要程序员自己去写sql 语句,不象hibernate 那样是完全面向对象的,自动化的,ibatis 是半自动化的,通过表和对象的映射以及手工书写的sql 语句,能够实现比hibernate 等更高的查询效率.Ibatis 只是封装了数据访问层,替我们做了部分的对象关系映射.但代价是必须要写xml配置文件,相对于Hibernate 还要写很多sql .Hibernate 通过工具直接从数据库模式生成实体类和基本的配置文件,而且大部分情况下不需要我们写sql ,会较大的提升开发效率.但这些也有很多的局限性,尤其是对环境的要求较高数据库设计,对象设计,团队的协作等. 个人感觉Ibatis 对项目比较有意义的地方在于它小巧灵活,可扩展,封装了数据访问层事务,缓存,异常,日志,并提供了DAO 框架支持.利用Ibatis 我们可以做到代码和sql 的分离,只要sql 能够解决的问题,Ibatis 就能帮我们较容易的解决,同时也使我们的项目对某一框架的依赖性变小因为Ibatis 是非侵入性的.这将极大的降低项目风险,减少解决复杂问题的时间,使项目的维护变得简单.Ibatis 对于应用的修改,调试,扩充和维护将会变得容易自然.修改时,我们主要修改的是代表模型的实体对象,xml 配置文件中的sql ,和/ 或配置文件的ResultMap 很多时候是不需要的.同时,sql 和代码分离,我们不用在代码的StringBuffer 的append 方法之间寻找需要修改的sql .配置文件中的sql 便利了我们的调试和对sql 的评审及以后的sql 重用.架构图Struts 是Apache 基金会Jakarta 项目组的一个Open Source 项目,它采用MVC 模式,能够很好地帮助java 开发者利用J2EE 开发Web 应用.和其他的java 架构一样,Struts 也是面向对象设计,将MVC 模式" 分离显示逻辑和业务逻辑" 的能力发挥得淋漓尽致.Structs 框架的核心是一个弹性的控制层,基于如Java Servlets ,JavaBeans ,ResourceBundles 与XML 等标准技术, 以及Jakarta Commons 的一些类库.Struts 有一组相互协作的类组件、Serlvet 以及jsp tag lib 组成.基于struts 构架的web 应用程序基本上符合JSP Model2 的设计标准,可以说是一个传统MVC 设计模式的一种变化类型.Struts 有其自己的控制器Controller ,同时整合了其他的一些技术去实现模型层Model 和视图层View .在模型层,Struts 可以很容易的与数据访问技术相结合,如JDBC / EJB ,以及其它第三方类库,如Hibernate / iBATIS ,或者Object Relational Bridge 对象关系桥 .在视图层,Struts 能够与JSP ,包括JSTL 与JSF ,以及Velocity 模板,XSLT 与其它表示层技术.Struts 为每个专业的Web 应用程序做背后的支撑,帮助为你的应用创建一个扩展的开发环境.Client browser 客户浏览器来自客户浏览器的每个HTTP 请求创建一个事件.Web 容器将用一个HTTP 响应作出响应.Controller 控制器控制器接收来自浏览器的请求,并决定将这个请求发往何处.就Struts 而言,控制器是以servlet 实现的一个命令设计模式. 文件配置控制器.业务逻辑业务逻辑更新模型的状态,并帮助控制应用程序的流程.就Struts 而言,这是通过作为实际业务逻辑“ 瘦” 包装的Action 类完成的.Model 模型的状态模型表示应用程序的状态.业务对象更新应用程序的状态.ActionForm. bean 在会话级或请求级表示模型的状态,而不是在持久级.JSP 文件使用JSP 标记读取来自ActionForm. bean 的信息.View 视图视图就是一个JSP 文件.其中没有流程逻辑,没有业务逻辑,也没有模型信息-- 只有标记.标记是使Struts 有别于其他框架如Velocity 的因素之一架构图Struts 2 相对于Struts ,将实现用户业务逻辑Action 同Servlet API 分离开,这种分离机制,是采用了拦截器或者拦截器栈拦截器链.拦截器是Struts 2 的核心内容之一.Struts 2 内建了多个拦截器和拦截器栈由多个拦截器形成的拦截器链,将用户的Web 请求进行拦截处理,从而提供了更加丰富的功能,例如数据类型转换、国际化、文件上传等.架构图Hibernate 是一个开放源代码的对象关系映射框架,它对JDBC 进行了非常轻量级的对象封装,使得Java 程序员可以随心所欲的使用对象编程思维来操纵数据库.Hibernate 可以应用在任何使用JDBC 的场合,既可以在Java 的客户端程序使用,也可以在Servlet/JSP 的Web 应用中使用,最具革命意义的是,Hibernate 可以在应用EJB 的J2EE 架构中取代CMP ,完成数据持久化的重任.Hibernate 的核心接口一共有5 个,分别为:Session 、、Transaction 、和Configuration .这5 个核心接口在任何开发中都会用到.通过这些接口,不仅可以对持久化对象进行存取,还能够进行事务控制.下面对这五个核心接口分别加以介绍.·Session 接口:Session 接口负责执行被持久化对象的CRUD 操作CRUD 的任务是完成与数据库的交流,包含了很多常见的SQL 语句. .但需要注意的是Session 对象是非线程安全的.同时,Hibernate 的session 不同于JSP 应用中的HttpSession .这里当使用session 这个术语时,其实指的是Hibernate 中的session ,而以后会将HttpSesion 对象称为用户session .·SessionFactory 接口:SessionFactory 接口负责初始化Hibernate .它充当数据存储源的代理,并负责创建Session 对象.这里用到了工厂模式.需要注意的是SessionFactory 并不是轻量级的,因为一般情况下,一个项目通常只需要一个SessionFactory 就够,当需要操作多个数据库时,可以为每个数据库指定一个SessionFactory .·Configuration 接口:Configuration 接口负责配置并启动Hibernate ,创建SessionFactory 对象.在Hibernate 的启动的过程中,Configuration 类的实例首先定位映射文档位置、读取配置,然后创建SessionFactory 对象.·Transaction 接口:Transaction 接口负责事务相关的操作.它是可选的,开发人员也可以设计编写自己的底层事务处理代码.·Query 和Criteria 接口:Query 和Criteria 接口负责执行各种数据库查询.它可以使用HQL 语言或SQL 语句两种表达方式.架构图J2EE 是一套全然不同于传统应用开发的技术架构,包含许多组件,主要可简化且规范应用系统的开发与部署,进而提高可移植性、安全与再用价值.J2EE 核心是一组技术规范与指南,其中所包含的各类组件、服务架构及技术层次,均有共通的标准及规格,让各种依循J2EE 架构的不同平台之间,存在良好的兼容性,解决过去企业后端使用的信息产品彼此之间无法兼容,导致企业内部或外部难以互通的窘境.架构图。
spring成神之路第三篇：Spring容器基本使用及原理（ApplicationCont。。。
spring成神之路第三篇：Spring容器基本使⽤及原理（ApplicationCont。
1. jdk1.82. idea3. maven-3.6.14. spring-5.2.3.RELEASEIOC容器是具有依赖注⼊功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个⽣命周期都是由容器来控制。
我们需要使⽤的对象都由ioc容器进⾏管理，不需要我们再去⼿动通过new的⽅式去创建对象，由ioc 容器直接帮我们组装好，当我们需要使⽤的时候直接从ioc容器中直接获取就可以了。
那么spring ioc容器是如何知道需要管理哪些对象呢？需要我们给ioc容器提供⼀个配置清单，这个配置⽀持xml格式和java注解的⽅式，在配置⽂件中列出需要让ioc容器管理的对象，以及可以指定让ioc容器如何构建这些对象，当spring容器启动的时候，就会去加载这个配置⽂件，然后将这些对象给组装好以供外部访问者使⽤。
这⾥所说的IOC容器也叫spring容器。
由spring容器管理的对象统称为Bean对象。
Bean就是普通的java对象，和我们⾃⼰new的对象其实是⼀样的，只是这些对象是由spring去创建和管理的，我们需要在配置⽂件中告诉spring容器需要创建哪些bean对象，所以需要先在配置⽂件中定义好需要创建的bean对象，这些配置统称为bean定义配置元数据信息，spring容器通过读取这些bean配置元数据信息来构建和组装我们需要的对象。
1. 引⼊spring相关的maven配置2. 创建bean配置⽂件，⽐如bean xml配置⽂件3. 在bean xml⽂件中定义好需要spring容器管理的bean对象4. 创建spring容器，并给容器指定需要装载的bean配置⽂件，当spring容器启动之后，会加载这些配置⽂件，然后创建好配置⽂件中定义好的bean对象，将这些对象放在容器中以供使⽤5. 通过容器提供的⽅法获取容器中的对象，然后使⽤spring内部提供了很多表⽰spring容器的接⼝和对象，我们来看看⽐较常见的⼏个容器接⼝和具体的实现类。
spring框架概述
spring框架概述1 spring框架概述1.1 什么是springSpring是⼀个开源框架，Spring是于2003 年兴起的⼀个轻量级的Java 开发框架，由Rod Johnson开发。
它是为了解决企业应⽤开发的复杂性⽽创建的。
框架的主要优势之⼀就是其分层架构，分层架构允许使⽤者选择使⽤哪⼀个组件，同时为J2EE 应⽤程序开发提供集成的框架dao(JdbcTemplate) service(spring控制事务) web(springmvc)Spring的核⼼是控制反转（IoC）和⾯向切⾯（AOP）。
简单来说，Spring是⼀个分层的JavaSE/EE full-stack 轻量级开源框架。
1）IoC 和DI 2）AOP⼀句话描述spring：full-stack 轻量级开源框架分层： full-stack，每⼀个层都提供解决⽅案web层：struts，spring-MVCservice层：spring 事务控制 springdao层：hibernate，mybatis ， jdbcTemplate（spring提供了⼀个模板对象） --> spring-datassh:struts2+spring+hibernate（以前的了解⼀下）ssm:spring+springmvc+mybatis（现阶段常⽤）1.2 spring核⼼Spring的核⼼是控制反转（IoC）和⾯向切⾯（AOP）1.3 spring优点1.4 spring体系结构核⼼容器：beans、core、context、expressiondao service 对象的创建交给spring2 ⼊门案例：IoC【掌握】2.1 导⼊jar包4 + 1 ： 4个核⼼（beans、core、context、expression） + 1个依赖（commons-loggins...jar）2.2 ⽬标类1. 提供UserService接⼝和实现类2. 获得UserService实现类的实例之前开发中，直接new⼀个对象即可。
Spring
Spring是一个轻量级的DI（IoC）和AOP容器框架。
存在的目的是用于构建轻量级的J2EE应用。
1.轻量级：应用大小和应用开支，包括应用方式2.DI（IoC)：提供松耦合的一种实现技术3.AOP：切面编程将业务逻辑从应用服务中分离4.容器：包含并管理应用对象的生命周期和配置5.框架：使用组件配置组合成复杂的应用，并提供很多基础功能项目中引入spring立即可以带来下面的好处1.降低组件之间的耦合度,实现软件各层之间的解耦。
2.可以使用容器提供的众多服务，如：事务管理服务、消息服务等等。
当我们使用容器管理事务时，开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。
3.容器提供单例模式支持，开发人员不再需要自己编写实现代码。
4.容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。
5.容器提供的众多辅作类，使用这些类能够加快应用的开发，如：JdbcT emplate、HibernateT emplate。
6.Spring对于主流的应用框架提供了集成支持，如：集成Hibernate、JPA、Struts等，这样更便于应用的开发。
第一个Spring应用(1):搭建环境,在spring最基础的应用中只需要dest\spring.jar和lib\jakarta-commons\commons-logging.jar新建spring的配置文件,文件名称可以任意,位置也可以任意,但考虑到通用性,一般将配置文件存放在类路径下,配置文件的模板可以在spring 参考手册中获取(查找中输入<bean>),模板大致如下：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd"></beans>(2):实例化spring容器,通过在类路径下寻找配置文件(配置文件可以有多个,以字符数组的形式传入)/* 当存在多个配置文件时,可以将spring配置文件名,字符串数组的形式传入 */ ApplicationContext ac = new ClassPathXmlApplicationContext("Spring-config.xml");(3):将实体bean的创建与维护交由spring管理在配置文件中的<beans>下使用<bean>标签<!—指定实体bean的名称,当名称含有特殊字符时,需要用name指定,一般情况下使用id,id 在配置文件中唯一,而name可以重复指定,获取时,获取到最后一个,在name中可以使用逗号将多个名称隔开,来达到指定bean的多个名称,当id和那么都没有指定时,则以类的全名作为name,如果存在多个name和id没有指定且实例类都是一样的bean,可以使用clazzpath/#来获取,#代表在xml中存在的序号--><!—calss指定需要被管理的实体bean,需要是完整的类名--><bean id="personService"class="com.mrkay.spring.services.impl.PersonServiceImpl"/> (4):调用实体bean使用实例化的spring容器的getBean(beanNa me)获取实体bean实例化bean的三种方式（1）：使用默认的构造函数进行实例化bean<bean id=”xxx” class=”xxx.xxx.Xxx”/>（2）：使用静态工厂方法创建bean<bean id=”xxx” class=”xxx.xxx.Xxx” factory-method=”xxxx”/>（3）：使用实例化工厂方法创建bean1,先实例化工厂<bean id=”factory” class=”xxx.xxx.Xxx”/>2,然后实例化bean <bean id=”xxx” class=”xxx.xxx.Xxx” factory-method=”xxxx”/>默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean会才初始化bean。
图解+仿写新手都能学懂的SpringBoot源码课完整版
图解+仿写新⼿都能学懂的SpringBoot源码课完整版
全⽅位深⼊解析最新版SpringBoot源码
课件获取链接：
当下SpringBoot⽇渐取代SSM成为新项⽬⾸选框架，企业招聘对其要求也不断提⾼。
掌握SpringBoot源码将助你⾼效定位和解决问题，仿写SpringBoot 源码将帮你养成规范的代码习惯，轻松应对⾼标准的企业开发与⾯试要求。
本课程通过图解+仿写教学模式，双管齐下，打造新⼿都能学得懂的源码课。
吃透Java开发热门框架源码，实⼒⽐肩阿⾥P6
锻造Java开发编程⾼⼿，⾯试脱颖⽽出，看得见的出彩
风向标级框架
Java新项⽬⾸选框架
下⼀代Java开发必会框架
源码驱动成长
快速锁定并解决开发问题
⼯作灵活运SpringBoot
重塑编程思维
提升编程内功
代码优雅⽽不失⾼效
⾯试游刃有余
源码⾯试信⼿拈来
把握⾯试主动权
课件获取链接：。
Spring中的常见的9种设计模式
Spring中的常见的9种设计模式1.简单⼯⼚(⾮23种设计模式中的⼀种)2.⼯⼚⽅法3.单例模式4.适配器模式5.装饰器模式6.代理模式7.观察者模式8.策略模式9.模版⽅法模式Spring中涉及的设计模式总结1.简单⼯⼚(⾮23种设计模式中的⼀种)实现⽅式：BeanFactory。
Spring中的BeanFactory就是简单⼯⼚模式的体现，根据传⼊⼀个唯⼀的标识来获得Bean对象，但是否是在传⼊参数后创建还是传⼊参数前创建这个要根据具体情况来定。
实质：由⼀个⼯⼚类根据传⼊的参数，动态决定应该创建哪⼀个产品类。
实现原理：bean容器的启动阶段：读取bean的xml配置⽂件,将bean元素分别转换成⼀个BeanDefinition对象。
然后通过BeanDefinitionRegistry将这些bean注册到beanFactory中，保存在它的⼀个ConcurrentHashMap中。
将BeanDefinition注册到了beanFactory之后，在这⾥Spring为我们提供了⼀个扩展的切⼝，允许我们通过实现接⼝BeanFactoryPostProcessor 在此处来插⼊我们定义的代码。
典型的例⼦就是：PropertyPlaceholderConfigurer，我们⼀般在配置数据库的dataSource时使⽤到的占位符的值，就是它注⼊进去的。
容器中bean的实例化阶段：实例化阶段主要是通过反射或者CGLIB对bean进⾏实例化，在这个阶段Spring⼜给我们暴露了很多的扩展点：各种的Aware接⼝，⽐如 BeanFactoryAware，对于实现了这些Aware接⼝的bean，在实例化bean时Spring会帮我们注⼊对应的BeanFactory的实例。
BeanPostProcessor接⼝，实现了BeanPostProcessor接⼝的bean，在实例化bean时Spring会帮我们调⽤接⼝中的⽅法。
《Spring框架》课件
Spring框架的开发 步骤
学习Spring框架的开发步骤， 从创建项目到部署应用程序。
Spring框架的调试 和维护
调试和维护Spring应用程序 是确保其正常运行的关键步 骤。
Spring框架的案例实现
Spring框架实现订单管理
使用Spring框架构建一个完整的订单管理系统，包括订单下单、查询、删除等功能。
Spring框架的发展历程
1
Spring框架的版本历史
Spring框架经历了多个版本的演变，每个版本都带来了新的功能和改进。
2
Spring框架的发展趋势来自Spring框架在不断发展中，将来可能会集成更多的技术和工具。
Spring框架的使用方法
Spring框架的安装 和配置
安装和配置Spring框架是使 用它的第一步，确保环境设 置正确。
Spring框架实现用户管理
使用Spring框架实现用户管理功能，包括用户注册、登录、修改个人信息等操作。
Spring框架的应用场景
Web应用程序开发
Spring框架提供了丰富的功能和工具，使得开发Web应用程序变得更加简单和高效。
企业应用程序开发
Spring框架提供了对企业级开发的良好支持，可以轻松应对复杂的业务需求。
移动应用程序开发
Spring框架可以与移动开发框架集成，快速构建高质量的移动应用程序。
Spring框架的扩展模块
Spring Web框架
Spring Web框架为构建Web应 用程序提供了一套工具和库。
Spring MVC框架
Spring MVC框架是基于模型视图-控制器（MVC）架构的 Web框架。
Spring Boot框架
Spring Boot框架简化了Spring 应用程序的配置和部署。
Spring系列之Spring常用注解总结
Spring系列之Spring常⽤注解总结Spring系列之Spring常⽤注解总结传统的Spring做法是使⽤.xml⽂件来对bean进⾏注⼊或者是配置aop、事物，这么做有两个缺点：1、如果所有的内容都配置在.xml⽂件中，那么.xml⽂件将会⼗分庞⼤；如果按需求分开.xml⽂件，那么.xml⽂件⼜会⾮常多。
总之这将导致配置⽂件的可读性与可维护性变得很低。
2、在开发中在.java⽂件和.xml⽂件之间不断切换，是⼀件⿇烦的事，同时这种思维上的不连贯也会降低开发的效率。
为了解决这两个问题，Spring引⼊了注解，通过"@XXX"的⽅式，让注解与Java Bean紧密结合，既⼤⼤减少了配置⽂件的体积，⼜增加了Java Bean的可读性与内聚性。
不使⽤注解：先看⼀个不使⽤注解的Spring⽰例，在这个⽰例的基础上，改成注解版本的，这样也能看出使⽤与不使⽤注解之间的区别，先定义⼀个⽼虎：package com.spring.model;public class Tiger {private String tigerName="TigerKing";public String toString(){return "TigerName:"+tigerName;}}再定义⼀个猴⼦：package com.spring.model;public class Monkey {private String monkeyName = "MonkeyKing";public String toString(){return "MonkeyName:" + monkeyName;}}定义⼀个动物园：package com.spring.model;public class Zoo {private Tiger tiger;private Monkey monkey;public Tiger getTiger() {return tiger;}public void setTiger(Tiger tiger) {this.tiger = tiger;}public Monkey getMonkey() {return monkey;}public void setMonkey(Monkey monkey) {this.monkey = monkey;}public String toString(){return tiger + "\n" + monkey;}}spring的配置⽂件这么写：<?xml version="1.0" encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"><bean id="zoo" class="com.spring.model.Zoo"><property name="tiger" ref="tiger"/><property name="monkey" ref="monkey"/></bean><bean id="tiger" class="com.spring.model.Tiger"/><bean id="monkey" class="com.spring.model.Monkey"/></beans>测试⽅法：public class TestAnnotation {/*** 不使⽤注解*/@Testpublic void test(){//读取配置⽂件ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext2.xml");Zoo zoo=(Zoo) ctx.getBean("zoo");System.out.println(zoo.toString());}}都很熟悉，权当复习⼀遍了。
Springboot集成activity过程图解
Springboot集成activity过程图解1.第⼀步添加bpmn⽂件得插件，不然没法查看和编辑bpmn⽂件，添加插件的⽅法各⾃百度即可，很简单2.安装好bpmn插件后开始新建bpmn⽂件，也就是画流程图⼀般是在代码中进⾏指定流程审批⼈的，我这⾥只做⼊门案例这⾥包含了在线设计流程图的相关依赖，在下⼀篇会写出来，项⽬中⼀般都是在前端在线设计；所以直接放上去也没事<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 https:///xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.2.0.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com</groupId><artifactId>springboot_activiti</artifactId><version>0.0.1-SNAPSHOT</version><name>springboot_activiti</name><description>Demo project for Spring Boot</description><properties><springboot.version>2.2.0.RELEASE</springboot.version><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><java.version>1.8</java.version><activiti.version>6.0.0</activiti.version></properties><dependencies><dependency><groupId>org.activiti</groupId><artifactId>activiti-engine</artifactId><version>${activiti.version}</version></dependency><dependency><groupId>org.activiti</groupId><artifactId>activiti-spring</artifactId><version>${activiti.version}</version><exclusions><exclusion><groupId>org.codehaus.jackson</groupId><artifactId>jackson-core-asl</artifactId></exclusion><exclusion><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId></exclusion><exclusion><artifactId>spring-context</artifactId><groupId>org.springframework</groupId></exclusion><exclusion><artifactId>spring-jdbc</artifactId><groupId>org.springframework</groupId></exclusion><exclusion><artifactId>spring-tx</artifactId><groupId>org.springframework</groupId></exclusion><exclusion><artifactId>spring-orm</artifactId><groupId>org.springframework</groupId></exclusion><exclusion><artifactId>spring-beans</artifactId><groupId>org.springframework</groupId></exclusion><exclusion><artifactId>mybatis</artifactId><groupId>org.mybatis</groupId></exclusion><exclusion><artifactId>activation</artifactId><groupId>javax.activation</groupId></exclusion></exclusions></dependency><dependency><groupId>org.activiti</groupId><artifactId>activiti-spring-boot-starter-basic</artifactId><version>${activiti.version}</version></dependency><!-- Activiti 流程图 --><dependency><groupId>org.activiti</groupId><artifactId>activiti-common-rest</artifactId><version>${activiti.version}</version></dependency><!-- Activiti 在线设计 --><dependency><groupId>org.activiti</groupId><artifactId>activiti-modeler</artifactId><version>5.22.0</version><exclusions><exclusion><artifactId>spring-beans</artifactId><groupId>org.springframework</groupId></exclusion><exclusion><artifactId>spring-context</artifactId><groupId>org.springframework</groupId></exclusion><exclusion><artifactId>spring-core</artifactId><groupId>org.springframework</groupId></exclusion><exclusion><artifactId>spring-tx</artifactId><groupId>org.springframework</groupId></exclusion><exclusion><artifactId>spring-web</artifactId><groupId>org.springframework</groupId></exclusion><artifactId>spring-security-config</artifactId><groupId>org.springframework.security</groupId></exclusion><exclusion><artifactId>spring-security-core</artifactId><groupId>org.springframework.security</groupId></exclusion><exclusion><artifactId>spring-security-crypto</artifactId><groupId>org.springframework.security</groupId></exclusion><exclusion><artifactId>spring-security-web</artifactId><groupId>org.springframework.security</groupId></exclusion><exclusion><artifactId>spring-webmvc</artifactId><groupId>org.springframework</groupId></exclusion><exclusion><artifactId>activation</artifactId><groupId>javax.activation</groupId></exclusion><exclusion><artifactId>commons-io</artifactId><groupId>commons-io</groupId></exclusion></exclusions></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-autoconfigure</artifactId><version>${springboot.version}</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-tomcat</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-thymeleaf</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>commons-io</groupId><artifactId>commons-io</artifactId><version>2.3</version></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-core</artifactId><version>2.10.0</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><version>RELEASE</version><scope>compile</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin><plugin><groupId>org.apache.tomcat.maven</groupId><artifactId>tomcat7-maven-plugin</artifactId><configuration><port>8081</port><path>/activity</path><systemProperties><com.sun.management.jmxremote.port>4000</com.sun.management.jmxremote.port></systemProperties></configuration></plugin></plugins></build></project>4.yml⽂件这⾥采⽤的数据库还是mysql这⾥有个需要注意的地⽅，springboot2.2中的driver-class-name值变了，不是以前的那个了，不然会报错spring:datasource:url: jdbc:mysql://localhost:3307/t2?useUnicode=true&characterEncoding=utf-8&useSSL=false&autoReconnect=true&serverTimezone=UTC username: rootpassword: rootdriver-class-name: com.mysql.cj.jdbc.Driveractiviti:# ⾃动部署验证设置:true-开启（默认）、false-关闭check-process-definitions: false#⾃动部署⽂件路径后缀# process-definition-location-prefix: classpath:/processes/# process-definition-location-suffixes:# - **.bpmn# - **.bpmn20.xmlserver:port: 80825.配置已经好了，下⾯开始写代码了，只是初步写了⼀些新建流程，正常提交流程，直接结束流程，以及查询待办的案例，细节还需要各⾃⾃⼰去调试学习controllerpackage com.springboot_activiti.controller;import com.springboot_activiti.service.ActivityConsumerService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;@RestController@RequestMapping("/activiti")public class ActivitiController {@Autowiredprivate ActivityConsumerService activityConsumerService;/*** 注册流程* @return*/@RequestMapping("/createDeployment")public Boolean createDeployment(){return activityConsumerService.createDeployment();}/*** 启动流程* @return*/@RequestMapping("/startActivityDemo")public Boolean startActivityDemo(){return activityConsumerService.startActivityDemo("test01");}/*** 获取待办* @return*/@RequestMapping("/getTaskList")public boolean getTaskList(){return activityConsumerService.getTaskList();}/*** 提交* @param taskId* @return*/@RequestMapping("/complete")public boolean complete(String taskId){return plete(taskId);}/*** 根据流程id直接结束流程* @paramru* @return*/@RequestMapping("/deleteProcessInstance")public boolean deleteProcessInstance(String runId){return activityConsumerService.deleteProcessInstance(runId);}}servicepackage com.springboot_activiti.service;public interface ActivityConsumerService {boolean createDeployment();boolean startActivityDemo(String key);boolean getTaskList();boolean complete(String taskId);boolean deleteProcessInstance(String runId);}实现类package com.springboot_activiti.service;import org.activiti.engine.RepositoryService;import org.activiti.engine.RuntimeService;import org.activiti.engine.TaskService;import org.activiti.engine.repository.DeploymentBuilder;import org.activiti.engine.runtime.ProcessInstance;import org.activiti.engine.task.Task;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.util.List;@Service("activityService")public class ActivityConsumerServiceImpl implements ActivityConsumerService {@Autowiredprivate RuntimeService runtimeService;@Autowiredprivate TaskService taskService;@Autowiredprivate RepositoryService repositoryService;/*** 注册⼀个流程* @return*/@Overridepublic boolean createDeployment() {DeploymentBuilder builder=repositoryService.createDeployment();builder.addClasspathResource("test01.bpmn");builder.deploy();return true;}/*** 查询待办* @return*/public boolean getTaskList(){//获取待办的⼀些信息，这⾥可以传⼊需要查询的⽤户，//我这⾥查询的所有待办List<Task> tasks = taskService.createTaskQuery().list();for (Task t:tasks) {System.out.println(t.getCreateTime());System.out.println(t.getId());System.out.println(t.getName());System.out.println(t.getProcessInstanceId());System.out.println(t.getTaskDefinitionKey());System.out.println(t.getParentTaskId());}return true;}/*** 根据流程key开启⼀个流程* @param key* @return*/@Overridepublic boolean startActivityDemo(String key) {ProcessInstance test01 = runtimeService.startProcessInstanceByKey(key);String id = test01.getId();System.out.println("流程id="+id);/* *//* String assignee = "abc";*/return true;}/*** 根据任务id提交任务* @param taskId* @return*/@Overridepublic boolean complete(String taskId){plete(taskId);return true;}/*** 根据流程id直接结束流程* @param runId* @return*/@Overridepublic boolean deleteProcessInstance(String runId){runtimeService.deleteProcessInstance(runId,"结束");return true;}}启动类，这⾥存在⼀个在线视图设计的验证处理，package com.springboot_activiti;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.EnableAutoConfiguration;import org.springframework.boot.autoconfigure.SpringBootApplication;import ponentScan;@ComponentScan("com")@SpringBootApplication@EnableAutoConfiguration(exclude = {org.activiti.spring.boot.SecurityAutoConfiguration.class})public class SpringbootActivitiApplication {public static void main(String[] args) {SpringApplication.run(SpringbootActivitiApplication.class, args);}}所有的代码已经写好了备注说明：项⽬启动会新建28张表，各⾃代表的含义⾃⾏百度把因为我的数据都是直接在流程图bpmn⽂件⾥⾯写好的，实际中肯定是在代码⾥⾯指定的⾸先访问注册流程启动流程（会返回⼀个流程id）查看待办就可以获取相关的信息了正常提交任务，会审批到下⼀节点（查看待办可以得到任务id）直接结束流程（⾮正常结束，启动流程的id传⼊即可）请求案例查询待办启动流程以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
spring 的层次图
login.jsp V
Action.java 处理器
struts.xml
UsersService.java 业务层
Users.java[domain 对象/javabean/pojo]
dao(UsersDao/Hiber nateUtil.java)
hibernate(orm 框架)，持久层体现oop,主要解决关系模型和
数据库
spring 框
jsp / action 主要体现出mvc 的数据输入、数据的处理，数据的显示分离
这里强调一下，在一个项目中不一定全部有，可以根据实际情况选择.
接口
目标对象
UserService
DepartmentService
OrderServicer
begingTransacton()
aop 原理+案例先不说，当我们概念)
//传统方法
ac.getBean("??").say()..
类(可以完成写日[术语通知,sprin 了五种通知.]前置通知before ...写日志代码
代理对象(spring 提供了ProxyFactoryBean).该对象只而不要写.使用到动态代理技
代理接口，完成代理任务.sayHello(){hi.xx
织入(过程)
连接点->切入点交叉功能(切面)
后置通知完成资源关闭
连接点环绕通知
引入通知
501
号
队列池
雇员薪资管理系
Employee.java
@Transacti EmployeeSe va[业务操作
hibernate
EmployeeServ er
login.jsp 提交:
LoginAction.j ava
表单属性
失败
根目录寻找配置文前缀指定从类路value>classpath:applicationContext.xml</param-value>class>org.springframework.web.context.ContextLoaderLi
sping框架.它可以管理
web层,业务层.dao层
持久层,该sping可以配置各个的组件(bean),并且维护各个bean之间的关系.
配置各种bean
<bean id><
<property
value="hello"></propery> </bean>
<bean id><
<property ref=""></propery </bean>
web 层action[解决action单问题]
业务层service/domain/dao 持久层: 数据
源
,localSessionFactory
案例(aop 中有很多概念，当我们讲完案例后，在看
Test1Service sayHello()sayBye();
Test2Service sayHello()
TestServiceInter[接口]public void sayHello()
需求：在调用Test1Service sayHello()前完成日志记录调用Test2Service 的sayHell() 前完成日志需求: 在调用syaBye 函数的时候，完成日志记录.
需求:在调用完Test1Service 的sayHello()后，完成资源的关闭需求:
需求: 我们只希望在调用sayHello()时，来进行前置通知出
成写日志的功能)spring 框架提供fore 函数.代码
了
对象只需配置，代理技术
任务.
TestService public void
Test3Se sayBye(
4
置各个层各个
ry> opery>
ion单例/dao。