Spring教程

合集下载

SpringWebFlux基础教程：快速入门

SpringWebFlux基础教程：快速⼊门为什么要创建Spring WebFlux ?⼀⽅⾯是需要⼀个⾮阻塞的web 技术栈使⽤少量的线程和硬件资源来处理并发。

另⼀⽅⾯就是函数式编程。

什么是响应式？响应式是制围绕响应改变⽽构建的编程模型。

例如，响应I/O事件的⽹络组件、响应⿏标事件的UI控制器等等。

快速⼊门本⽂我们将学习如何快速构建Spring WebFlux 应⽤，实现⼀个简单的Http处理。

⼀、创建基础项⽬由于Spring WebFlux是基于Spring Framework 5.0，以及Spring Boot 2.0 基于Spring FrameWork 5.0，所以我们使⽤Spring Boot 2.0+ 来构建项⽬。

Spring 官⽅提供了⼯具，帮助我们快速的⽣成Spring Boot 项⽬。

⼆、将项⽬导⼊到 IDEA 中pom.xml⽂件<?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.5.3</version><relativePath/> </parent><groupId>com.example</groupId><artifactId>demo</artifactId><version>0.0.1-SNAPSHOT</version><name>demo</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-webflux</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>io.projectreactor</groupId><artifactId>reactor-test</artifactId><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>三、编写⼀个HTTP 接⼝创建package 为com.example.springbootdemo.webflux创建HelloHandler类，内容如下：@Componentpublic class HelloHandler {public Mono<ServerResponse> greeting(ServerRequest request) {return ServerResponse.ok().bodyValue("Hello World");}}创建HelloRouter类，路由规则，内容如下：@Configurationpublic class HelloRouter {@Beanpublic RouterFunction<ServerResponse> routes(HelloHandler helloHandler) {return RouterFunctions.route(RequestPredicates.GET("/hello"), helloHandler::greeting);}}启动主程序，使⽤Postman⼯具或者浏览器发起请求：http://localhost:8080/hello，可以看到返回结果：Hello World ⾄此使⽤ Spring WebFlux 构建了⼀个简单的请求项⽬。

最全最经典spring_mvc教程

spring mvc学习教程(一)-入门实例引言1.MVC：Model-View-Control框架性质的C层要完成的主要工作：封装web请求为一个数据对象、调用业务逻辑层来处理数据对象、返回处理数据结果及相应的视图给用户。

2.简要概述springmvcSpring C 层框架的核心是DispatcherServlet，它的作用是将请求分发给不同的后端处理器，也即使用了一种被称为Front Controller 的模式（后面对此模式有简要说明）。

Spring 的C 层框架使用了后端控制器来、映射处理器和视图解析器来共同完成C 层框架的主要工作。

并且spring 的C 层框架还真正地把业务层处理的数据结果和相应的视图拼成一个对象，即我们后面会经常用到的ModelAndView 对象。

一、入门实例1. 搭建环境在spring的官方API文档中，给出所有包的作用概述，现列举常用的包及相关作用：org.springframework.aop-3.0.5.RELEASE.jar：与Aop编程相关的包org.springframework.beans-3.0.5.RELEASE.jar：提供了简捷操作bean的接口org.springframework.context-3.0.5.RELEASE.jar：构建在beans包基础上，用来处理资源文件及国际化。

org.springframework.core-3.0.5.RELEASE.jar：spring核心包org.springframework.web-3.0.5.RELEASE.jar：web核心包，提供了web层接口org.springframework.web.servlet-3.0.5.RELEASE.jar：web 层的一个具体实包，DispatcherServlet也位于此包中。

后文全部在spring3.0 版本中进行，为了方便，建议在搭建环境中导入spring3.0 的所有jar 包（所有jar 包位于dist 目录下）。

Spring MVC 简明教程

Spring框架从创建伊始就致力于为复杂问题提供强大的、非侵入性的解决方案。

Spring 2.0当中为缩减XML配置文件数量引入定制命名空间功能，从此它便深深植根于核心Spring框架（aop、context、jee、jms、 lang、tx和util命名空间）、Spring Portfolio项目（例如Spring Security）和非Spring项目中（例如CXF）。

Spring 2.5推出了一整套注解，作为基于XML的配置的替换方案。

注解可用于Spring管理对象的自动发现、依赖注入、生命周期方法、Web层配置和单元/集成测试。

探索Spring 2.5中引入的注解技术系列文章由三部分组成，本文是其中的第二篇，它主要讲述了Web层中的注解支持。

最后一篇文章将着重介绍可用于集成和测试的其它特性。

这个系列文章的第一部分论述了Java注解（annotation）是如何代替XML来配置Spring管理对象和依赖注入的。

我们再用一个例子回顾一下：@Controllerpublic class ClinicController {private final Clinic clinic;@Autowiredpublic ClinicController(Clinic clinic) {this.clinic = clinic;}...@Controller表明ClinicController是Web层组件，@Autowired请求一个被依赖注入的Clinic实例。

这个例子只需要少量的XML语句就能使容器识别两个注解，并限定组件的扫描范围：<context:component-scanbase-package="org.springframework.samples.petclinic"/>这对Web层可谓是个福音，因为在这层Spring的XML配置文件已日益臃肿，甚至可能还不如层下的配置来得有用。

【SpringFramework】Spring入门教程（三）使用注解配置

【SpringFramework】Spring⼊门教程（三）使⽤注解配置本⽂主要介绍四个⽅⾯：(1) 注解版本IOC和DI(2) Spring纯注解(3) Spring测试(4) SpringJDBC - Spring对数据库的操作使⽤注解配置Spring⼊门说在前⾯学习基于注解的IoC配置，⼤家脑海⾥⾸先得有⼀个认知，即注解配置和xml配置要实现的功能都是⼀样的，都是要降低模块间的耦合度。

仅仅只是配置的形式不⼀样。

关于实际的开发中到底使⽤xml还是注解，每家公司有着不同的使⽤习惯。

所以这两种配置⽅式我们都需要掌握。

基于注解配置的⽅式也已经逐渐代替xml配置。

所以我们必须要掌握使⽤注解的⽅式配置Spring。

配置步骤注意：如果使⽤Eclipse需要先安装了STS插件，或者使⽤STS开发⼯具创建项⽬。

本⽂使⽤IDEA进⾏演⽰。

1.2.1. 第⼀步：拷贝必备jar包到⼯程的lib⽬录。

注意：在基于注解的配置中，我们还要多拷贝⼀个aop的jar包。

如下图：1.2.2. 第⼆步：在类的根路径下创建⼀个任意名称的xml⽂件（不能是中⽂）注意：基于注解整合时，Spring配置⽂件导⼊约束时需要多导⼊⼀个context命名空间下的约束。

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"></beans>1.2.3. 第⼆步：创建⼀个服务类创建⼀个测试的服务类，并且加⼊使⽤@Component注解，声明该类允许注⼊到Spring容器package org.cjw.service;import ponent;/*使⽤注解配置时，需要将Spring框架启动就创建对象的类表⽰为组件类表⽰组件类使⽤@Component注解*/@Componentpublic class CustomerService {public void save() {System.out.println("-保存数据-");}}1.2.4. 第四步在spring的配置⽂件加⼊扫描注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"><context:component-scan base-package="org.cjw" /></beans>1.2.5. 第五步：测试调⽤代码package org.cjw.test;import org.cjw.service.CustomerService;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class CustomerServiceTest {@Testpublic void testSave() {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");CustomerService customerService = context.getBean(CustomerService.class);customerService.save();}}--测试结果，如果可以调⽤服务⽅法，测试成功。

springspringboot整合dubbo详细教程

springspringboot整合dubbo详细教程⽬录⼀、基本使⽤⼆、spring整合dubbo2.1 spring-common模块：2.2 spring-user模块：2.3 spring-order模块：2.4 效果三、springboot整合dubbo3.1 boot-common模块：3.2 boot-user模块：3.3 boot-order模块：3.4 效果⼀、基本使⽤需求：某个电商系统，订单服务需要调⽤⽤户服务获取某个⽤户的所有地址；我们现在需要创建两个服务模块进⾏测试模块功能订单服务web模块创建订单等⽤户服务service模块查询⽤户地址等测试预期结果：订单服务web模块在A服务器，⽤户服务模块在B服务器，A可以远程调⽤B的功能。

⼆、spring整合dubbo以下使⽤XML 配置的⽅式，更多配置⽅式见2.1 spring-common模块：公共接⼝层（model，service，exception…），定义公共接⼝，也可以导⼊公共依赖UserAddress.java：⽤户地址实体类public class UserAddress implements Serializable {private Integer id;private String userAddress;private String userId;private String consignee;private String phoneNum;private String isDefault;....}IOrderService.java：订单接⼝public interface IOrderService {/*** ⽤户下单* @param userId*/UserAddress placeOrder(int userId);}IUserService.java：⽤户接⼝public interface IUserService {/*** 根据⽤户id获取⽤户地址* @param userId* @return*/UserAddress getUserAddById(int userId);}pom.xml：通⽤的依赖，引⼊dubbo和zkclient<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"> <parent><artifactId>dubboStudy</artifactId><groupId>org.example</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>spring-common</artifactId><properties><piler.source>8</piler.source><piler.target>8</piler.target></properties><dependencies><dependency><groupId>com.alibaba</groupId><artifactId>dubbo</artifactId><version>2.5.10</version></dependency><dependency><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId><version>3.4.6</version></dependency><dependency><groupId>com.github.sgroschupf</groupId><artifactId>zkclient</artifactId><version>0.1</version></dependency></dependencies></project>2.2 spring-user模块：⽤户业务，作为服务提供者pom.xml：引⼊通⽤模块，可以使⽤定义的接⼝<dependency><groupId>org.example</groupId><artifactId>spring-common</artifactId><version>1.0-SNAPSHOT</version></dependency>UserServiceImpl.xml：IUserService的实现类，供远程调⽤public class UserServiceImpl implements IUserService {@Overridepublic UserAddress getUserAddById(int userId) {UserAddress userAddress = new UserAddress();userAddress.setUserAddress("上海市宝⼭区");return userAddress;}}provider.xml：dubbo配置信息<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:dubbo="/schema/dubbo"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd /schema/dubbo /schema/dubbo/dubbo.xsd/schema/dubbo /schema/dubbo/dubbo.xsd"><dubbo:application name="spring-user"/><dubbo:registry address="zookeeper://192.168.31.136:2181"/><dubbo:protocol name="dubbo" port="20880"/><bean id="userServiceImpl" class="erServiceImpl"/><dubbo:service interface="me.nic.service.IUserService" ref="userServiceImpl"/></beans>ConsumerRun.java：启动：public class ConsumerRun {public static void main(String[] args) throws IOException {ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("consumer.xml");IOrderService orderService = applicationContext.getBean(IOrderService.class);orderService.placeOrder(1);System.in.read();}}2.3 spring-order模块：订单业务，作为服务消费者pom.xml：引⼊通⽤模块，可以使⽤定义的接⼝，同1.2OrderServiceImpl.xml：IOrderService的实现类，其中远程调⽤userService@Servicepublic class OrderServiceImpl implements IOrderService {@Autowiredprivate IUserService userService;@Overridepublic UserAddress placeOrder(int userId) {// 远程调⽤，获取⽤户地址UserAddress userAddById = userService.getUserAddById(userId);// 下单System.out.println("⽤户地址：" + userAddById.getUserAddress());System.out.println("下单成功");return null;}}consumer.xml：dubbo配置信息<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:dubbo="/schema/dubbo"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd /schema/context /schema/context/spring-context-4.3.xsd/schema/dubbo /schema/dubbo/dubbo.xsd/schema/dubbo /schema/dubbo/dubbo.xsd"><context:component-scan base-package="me.nic.service.impl"/><dubbo:application name="spring-order"/><dubbo:registry address="zookeeper://192.168.31.136:2181"/><dubbo:reference id="userService" interface="me.nic.service.IUserService"/></beans>ProviderRun.java：启动public class ProviderRun {public static void main(String[] args) throws IOException {ClassPathXmlApplicationContext context =new ClassPathXmlApplicationContext("classpath:provider.xml");System.in.read();}2.4 效果ProviderRun启动之后阻塞，ConsumerRun启动之后调⽤orderService.placeOrder(1)，placeOrder中远程调⽤spring-user模块中的userService.getUserAddById(userId)获取⽤户地址：⽤户地址：上海市宝⼭区下单成功三、springboot整合dubbo3.1 boot-common模块：公共接⼝层（model，service，exception…），定义公共接⼝，也可以导⼊公共依赖UserAddress.java：⽤户地址实体类public class UserAddress implements Serializable {private Integer id;private String userAddress;private String userId;private String consignee;private String phoneNum;private String isDefault;....}IOrderService.java：订单接⼝public interface IOrderService {/*** ⽤户下单* @param userId*/UserAddress placeOrder(int userId);}IUserService.java：⽤户接⼝public interface IUserService {/*** 根据⽤户id获取⽤户地址* @param userId* @return*/UserAddress getUserAddById(int userId);pom.xml：通⽤的依赖，引⼊dubbo的starter<?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.5.0</version><relativePath/></parent><groupId>com.example</groupId><artifactId>boot-common</artifactId><version>0.0.1-SNAPSHOT</version><name>boot-common</name><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>com.alibaba.boot</groupId><artifactId>dubbo-spring-boot-starter</artifactId><version>0.2.0</version></dependency></dependencies></project>3.2 boot-user模块：⽤户业务，作为服务提供者pom.xml：引⼊通⽤模块，可以使⽤定义的接⼝<dependency><groupId>org.example</groupId><artifactId>spring-common</artifactId><version>1.0-SNAPSHOT</version></dependency>UserServiceImpl.xml：IUserService的实现类，供远程调⽤@Service暴露dubbo的服务@Service@Componentpublic class UserServiceImpl implements IUserService {@Overridepublic UserAddress getUserAddById(int userId) {UserAddress userAddress = new UserAddress();userAddress.setUserAddress("上海市宝⼭区");return userAddress;}}application.properties：dubbo配置信息=boot-userdubbo.registry.address=192.168.31.136:2181dubbo.registry.protocol=zookeeper=dubbodubbo.protocol.port=20880BootUserApplication.java：启动：@EnableDubbo : 开启基于注解的dubbo功能@EnableDubbo@SpringBootApplicationpublic class BootUserApplication {public static void main(String[] args) {SpringApplication.run(BootUserApplication.class, args);}}3.3 boot-order模块：订单业务，作为服务消费者pom.xml：引⼊通⽤模块，可以使⽤定义的接⼝，同1.2<dependency><groupId>com.example</groupId><artifactId>boot-common</artifactId><version>0.0.1-SNAPSHOT</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>OrderServiceImpl.xml：IOrderService的实现类，其中远程调⽤userService@Reference：引⽤远程提供者服务@Servicepublic class OrderServiceImpl implements IOrderService {//引⽤远程提供者服务@Referenceprivate IUserService userService;@Overridepublic UserAddress placeOrder(int userId) {// 远程调⽤，获取⽤户地址UserAddress userAddById = userService.getUserAddById(userId);return userAddById;}}OrderController.java：web接⼝，调⽤OrderService：@Controllerpublic class OrderController {@AutowiredIOrderService orderService;@RequestMapping("/initOrder")@ResponseBodypublic UserAddress initOrder(@RequestParam("uid")int userId) {return orderService.placeOrder(userId);}}application.properties：dubbo配置信息server.port=8081=boot-orderdubbo.registry.address=zookeeper://192.168.31.136:2181BootOrderApplication.java：启动@EnableDubbo@SpringBootApplicationpublic class BootOrderApplication {public static void main(String[] args) {SpringApplication.run(BootOrderApplication.class, args);}}3.4 效果到此这篇关于springboot整合dubbo详细教程的⽂章就介绍到这了,更多相关springboot整合dubbo内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

spring学习教程之@ModelAttribute注解运用详解

spring学习教程之@ModelAttribute注解运⽤详解本⽂主要给⼤家介绍了关于java中@ModelAttribute使⽤的相关资料，分享出来供⼤家参考学习，下⾯来⼀起看看详细的介绍：⼀、@ModelAttribute注释⽅法例⼦（1），（2），（3）类似，被@ModelAttribute注释的⽅法会在此controller每个⽅法执⾏前被执⾏，因此对于⼀个controller映射多个URL的⽤法来说，要谨慎使⽤。

（1）@ModelAttribute注释void返回值的⽅法@Controllerpublic class HelloWorldController {@ModelAttributepublic void populateModel(@RequestParam String abc, Model model) {model.addAttribute("attributeName", abc);}@RequestMapping(value = "/helloWorld")public String helloWorld() {return "helloWorld";}}这个例⼦，在获得请求/helloWorld 后，populateModel⽅法在helloWorld⽅法之前先被调⽤，它把请求参数（/helloWorld? abc=text）加⼊到⼀个名为attributeName的model属性中，在它执⾏后helloWorld被调⽤，返回视图名helloWorld和model已由@ModelAttribute⽅法⽣产好了。

这个例⼦中model属性名称和model属性对象有model.addAttribute()实现，不过前提是要在⽅法中加⼊⼀个Model类型的参数。

当URL或者post中不包含次参数时，会报错，其实不需要这个⽅法，完全可以把请求的⽅法写成，这样缺少此参数也不会出错@RequestMapping(value = "/helloWorld")public String helloWorld(String abc) {return "helloWorld";}（2）@ModelAttribute注释返回具体类的⽅法@ModelAttributepublic Account addAccount(@RequestParam String number) {return accountManager.findAccount(number);}这种情况，model属性的名称没有指定，它由返回类型隐含表⽰，如这个⽅法返回Account类型，那么这个model属性的名称是account。

java spring 入门教程

java spring 入门教程Java Spring是一个开源的轻量级Java开发框架，是当今Java企业级应用开发的首选框架之一。

它提供了一个全面的编程和配置模型，可以帮助开发者更加高效地构建可靠的、灵活的、可扩展的企业级应用。

首先，Java Spring框架的核心概念是控制反转（IoC）和面向切面编程（AOP）。

控制反转是指将对象的创建、组装和管理等工作交给Spring容器来完成，而不是由开发者手动创建和管理。

这样做的好处是降低了开发复杂度，提高了代码的可测试性和可维护性。

面向切面编程是指通过横切关注点将应用程序业务逻辑与系统级服务（如日志记录、事务管理等）进行解耦，从而提高代码的可重用性和可维护性。

其次，Java Spring框架提供了一系列的容器和模块，用于支持不同层次的应用开发。

其中，核心容器包括BeanFactory和ApplicationContext，用于管理和控制对象的生命周期。

数据访问模块提供了对数据库访问的支持，包括对JDBC、ORM框架如Hibernate、MyBatis和Spring Data等的集成。

还有Web开发模块，提供了对Servlet、WebSocket、RESTful服务等的支持。

此外，还有安全性、消息队列、缓存等模块可以根据需要进行集成和使用。

此外，Java Spring还采用了一种基于注解的开发模式，使得开发者可以通过简单的注解配置和元数据来实现各种功能。

比如，使用@Component注解可以将一个Java类标记为一个可被Spring容器管理的Bean；使用@Autowired注解可以自动装配Bean之间的依赖关系；使用@Controller和@RequestMapping注解可以实现Web请求的处理等。

这种开发方式提高了开发效率，同时使得代码更加清晰和易于维护。

最后，Java Spring框架还提供了一系列的特性和工具，用于提高应用的性能和可用性。

比如，Spring Boot是一个快速构建应用程序的工具，通过自动配置和约定大于配置的原则，极大地简化了项目的搭建和部署。

Spring的JdbcTemplate使用教程

Spring的JdbcTemplate使⽤教程Spring对数据库的操作在jdbc上⾯做了基本的封装，让开发者在操作数据库时只需关注SQL语句和查询结果处理器，即可完成功能（当然，只使⽤JdbcTemplate，还不能摆脱持久层实现类的编写）。

在配合spring的IoC功能，可以把DataSource注册到JdbcTemplate之中。

同时利⽤spring基于aop的事务即可完成简单的数据库CRUD操作。

JdbcTemplate的限定命名为org.springframework.jdbc.core.JdbcTemplate。

要使⽤JdbcTemlate需要导⼊spring-jdbc和spring-tx两个坐标。

⽅法说明：execute⽅法：可以⽤于执⾏任何SQL语句，⼀般⽤于执⾏DDL语句；update⽅法及batchUpdate⽅法：update⽅法⽤于执⾏新增、修改、删除等语句；batchUpdate⽅法⽤于执⾏批处理相关语句；query⽅法及queryForXXX⽅法：⽤于执⾏查询相关语句；call⽅法：⽤于执⾏存储过程、函数相关语句。

使⽤案例项⽬结构：项⽬代码POM.XML<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.1.6.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.1.6.RELEASE</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.45</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.1.6.RELEASE</version></dependency></dependencies>实体类：public class Account implements Serializable {private Integer id;private String name;private Double money;//省略getter setter}public class Userinfo implements Serializable {private Integer id;private byte[] images; // 对应mysql数据库longBlob类型private String description; // 对应表的longText类型// 省略getter setter}相对应account表和userinfo表jdbc.propertiesjdbc.driver=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/spring_iocername=rootjdbc.password=adminjbbc配置类：public class JdbcConfig {@Value("${jdbc.driver}")private String driver;@Value("${jdbc.url}")private String url;@Value("${ername}")private String username;@Value("${jdbc.password}")private String password;/*** 创建数据源并存⼊Ioc容器* @return*/@Beanpublic DataSource createDataSource(){DriverManagerDataSource dataSource = new DriverManagerDataSource();dataSource.setDriverClassName(driver);dataSource.setUrl(url);dataSource.setUsername(username);dataSource.setPassword(password);return dataSource;}/*** 创建JdbcTemplate对象* @param dataSource* @return*/@Beanpublic JdbcTemplate createJdbcTemplate(DataSource dataSource){return new JdbcTemplate(dataSource);}// 操作clob和blob@Beanpublic LobHandler createLobHandler(){return new DefaultLobHandler();}}主配置类：@Configuration@Import(JdbcConfig.class)@PropertySource("classpath:jdbc.properties")public class SpringConfiguration {}测试类：/***注释部分为不同写法* 测试JdbcTemplate的使⽤*/@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes = SpringConfiguration.class)public class SpringJdbcTemplateTest {@Autowiredprivate JdbcTemplate jdbcTemplate;@Testpublic void testSave(){jdbcTemplate.update("insert into account(money,name)values(?,?)",6789d,"userTest");}@Testpublic void testUpdate(){jdbcTemplate.update("update account set name=?,money=? where id=?","testZZZ",23456d,3);}@Testpublic void testDelete(){jdbcTemplate.update("delete from account where id = ? ",4);}@Testpublic void testFindOne(){// List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),1); // System.out.println(accounts.isEmpty()?"empty":accounts.get(0));// Account account = jdbcTemplate.queryForObject("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),1);// System.out.println(account);Account account = jdbcTemplate.query("select * from account where id = ?", new ResultSetExtractor<Account>() {@Overridepublic Account extractData(ResultSet rs) throws SQLException, DataAccessException {Account account1 = null;//1.判断结果集能往下⾛if(rs.next()){account1 = new Account();account1.setId(rs.getInt("id"));account1.setName(rs.getString("name"));account1.setMoney(rs.getDouble("money"));}return account1;}}, 1);System.out.println(account);}@Testpublic void testFindAll(){List<Account> accountList = jdbcTemplate.query("select * from account where money > ?",new BeanPropertyRowMapper<Account>(Account.class),999d); for(Account account : accountList){System.out.println(account);}}@Testpublic void testFindCount(){Integer count = jdbcTemplate.queryForObject("select count(*) from account where money > ?",Integer.class,999d);System.out.println(count);}@Testpublic void testQueryForList(){/*** 得到某个特定类型的集合。

SpringBoot菜鸟教程(一)

SpringBoot菜鸟教程（一）SpringBoot菜鸟教程（一）一、什么是Spring Boot？1. 简化配置：Spring Boot利用一套默认的约定来实现自动配置，开发者可以少写大量的代码和配置，从而提高开发效率。

2. 内嵌服务器：Spring Boot可以将Tomcat、Jetty等Web服务器嵌入到应用程序中，无需手动配置。

3. 自动装配：Spring Boot会自动根据应用程序的依赖关系，自动装配相应的组件，无需手动配置。

4. 独立运行：Spring Boot应用程序可以以独立的形式运行，不再需要部署到外部服务器。

二、Spring Boot的快速入门1. 环境搭建：首先，需要确保Java和Maven已经安装好。

然后，创建一个新的Maven项目。

2. 引入依赖：在pom.xml文件中添加Spring Boot的依赖。

例如，可以添加spring-boot-starter-web依赖，用于搭建Web应用。

4. 运行程序：在命令行中切换到项目根目录，执行mvn spring-boot:run命令，即可启动Spring Boot应用程序。

5. 测试接口：通过浏览器或者Postman等工具，访问定义的API接口，检查返回的结果。

三、Spring Boot的应用场景1. Web应用：Spring Boot集成了Web开发所需的各种组件，可以用于快速搭建RESTful API、后台管理系统等Web应用。

2. 批处理应用：Spring Boot提供了Spring Batch模块，用于处理大量数据的批量处理任务。

3. 集成应用：Spring Boot可以轻松地集成各种数据库、消息队列、引擎等外部系统，用于构建复杂的集成应用。

4. 微服务：Spring Boot支持使用Spring Cloud构建分布式微服务架构，从而实现高可用、可扩展和可维护的系统。

四、Spring Boot的优势1. 简化开发：Spring Boot提供了默认的配置和约定，大大减少了开发者的工作量，从而提高了开发效率。

Spring3.0 MVC 中文教程

Spring3 MVC - 3到Spring MVC框架简介Spring3 MVC框架简介Spring MVC是Spring的框架的Web组件。

它提供了丰富的功能，为建设强大的Web应用程序。

Spring MVC框架的架构，并在这样的高度可配置的方式，每一块的逻辑和功能设计。

此外Spring可以毫不费力地与其他流行的Web框架，如Struts，WebWork的，的Java Server Faces和Tapestry集成。

这意味着，你甚至可以告诉Spring使用Web框架中的任何一个。

比Spring更不紧耦合的servlet或JSP 向客户端呈现视图。

喜欢速度与其他视图技术集成，Freemarker的，Excel或PDF现在也有可能。

Spring3.0 MVC系列∙第1部分：到Spring 3.0 MVC框架简介∙第2部分：在Spring 3.0 MVC创建Hello World应用程序∙第3部分：在Spring 3.0 MVC的形式处理∙第4部分：Spring3 MVC的Tiles Support与Eclipse中的例子插件教程∙第5部分：Spring3 MVC的国际化及本地化教程与范例在Eclipse∙第6部分：Spring3 MVC示例教程Spring主题∙第7部分：创建Spring3 MVC Hibernate 3的示例在Eclipse中使用Maven的在Spring Web MVC，你可以使用任何对象作为命令或表单支持对象，你不需要实现框架特定的接口或基类。

Spring的数据绑定是高度灵活的：例如，将验证错误类型不作为应用系统错误，可以通过评估的不匹配。

因此，你不必重复你的业务对象的属性，简单的无类型的字符串，在表单对象仅仅是为了处理无效的意见，或正确转换的字符串。

相反，它往往是最好直接绑定到业务对象。

请求处理生命周期Spring的Web MVC框架是，像许多其他Web MVC框架，要求为导向，围绕一个中心的servlet，它把请求分派给控制器，提供其他功能，有利于开发Web应用而设计的。

【SpringFramework】Spring入门教程（一）控制反转和依赖注入

【SpringFramework】Spring⼊门教程（⼀）控制反转和依赖注⼊参考资料说在前⾯什么样的架构，我们认为是⼀个优秀的架构？判断准则：可维护性好，可扩展性好，性能。

什么叫可扩展性好？答：在不断添加新的代码的同时，可以不修改原有代码，即符合开闭原则。

如何让程序的可维护性好，可扩展性好呢？业界有⼀个公认的标准：⾼内聚，低耦合。

⾼内聚：就是尽量将代码写在与之功能描述⼀致的模块中。

如User表的操作写在UserDAO⾥⾯，不要写在⾮UserDAO的类⾥⾯。

低耦合：就是尽量减少类与类之间的直接关系。

（重点）直接关系：Controller层依赖Service层，在Controller层直接new Service层的类的对象。

Service层依赖Dao层，在Service层直接new Dao层的对象。

Spring框架就是通过IoC/DI（控制反转/依赖注⼊）实现程序的解耦。

从⽽提⾼程序的维护性和扩展性。

Spring概述Spring是什么Spring是⼀个JavaEE轻量级的⼀站式开发框架。

JavaEE：就是⽤于开发企业级（B/S）应⽤的技术。

轻量级：使⽤最少代码启动框架，然后根据需求选择需要使⽤的模块。

重量级：早期的EJB，开发⼀个HelloWorld程序都需要引⼊EJB的全部模块。

⼀站式：提供了表⽰层，服务层，持久层的所有⽀持。

Spring框架出现的背景世界上第⼀套由Java官⽅Sun公司推出的企业级开发框架EJB瞬间风靡全球，被各⼤公司所应⽤。

Spring之⽗，Rod Jonhson是⼀个⾳乐博⼠，在Sun公司的⼤⼒推⼴下，也成为EJB框架的使⽤者。

在深⼊研究完EJB框架（由Sun主导开发的⼀个JavaEE开发框架），⽆法接受这么⼀个框架被吹成世界第⼀，具体查看他吐槽EJB的书《Expert one on one J2EE design and development》。

其中突出被他吐槽最厉害的⼀个点就EJB的重量级，就是只要使⽤EJB⾥⾯任何⼀个组件。

java spring 教程 pdf

java spring 教程 pdfJava Spring是一个开源的Java应用程序开发框架，主要用于快速开发Web应用程序和企业级应用。

它提供了一种简单而强大的方式来构建可扩展的、高效的应用程序。

Java Spring框架包含了一系列的模块，在开发过程中可以选择需要的模块来构建自己的应用。

其中最核心的模块是Spring Core，它提供了基本的依赖注入和控制反转功能，可以帮助开发者更好地组织和管理应用中的各个组件。

除了Spring Core，Java Spring还提供了许多其他有用的模块，比如Spring MVC用于构建Web应用程序的控制器、Spring Security用于处理安全性相关功能、Spring Data用于简化对数据库的访问等等。

这些模块可以根据项目需求进行选择和集成，以构建一个完整的应用。

Java Spring的优点之一是它的开发效率高。

通过使用Spring框架，开发者可以将重点放在业务逻辑的实现上，而无需关注底层的技术细节。

Spring提供了一种轻量级的框架来管理应用的各个组件和依赖关系，大大简化了开发过程，提高了开发效率。

另外，Java Spring还具有良好的可扩展性和灵活性。

Spring框架基于接口和依赖注入的设计原则，使得应用的不同组件之间松散耦合，易于替换和扩展。

开发者可以根据项目需要选择适合的模块来构建自己的应用，并可以很方便地对框架进行定制和扩展。

Java Spring的学习曲线相对较陡峭，需要一定的Java编程基础和对面向对象编程的理解。

但一旦掌握了Java Spring的基本概念和核心功能，就能够轻松地构建出高效、可扩展的应用程序。

总的来说，Java Spring是一个功能强大、灵活性高且易于使用的Java框架，适用于各种规模的应用开发项目。

通过学习和使用Java Spring，开发者可以快速构建出高效、可扩展的应用程序，并且可以很方便地进行定制和扩展，提高开发效率。

spring执行流程

spring执行流程Spring执行流程可以分为四个步骤：配置阶段、实例化阶段、初始化阶段和使用阶段。

配置阶段：在配置阶段，Spring框架会读取并解析XML配置文件，或者通过Java注解配置，来获取应用程序的配置信息。

配置信息包括对象的定义、对象之间的关系以及被注入的属性等等。

Spring提供了许多个性化的配置选项，以及方便的注解方式，可以根据具体的需求灵活配置。

实例化阶段：在实例化阶段，Spring框架会根据配置文件中的定义，通过反射机制或者工厂方法来创建相应的对象实例。

Spring支持不同的实例化方式，包括单例模式、原型模式、会话模式、请求模式等等。

在实例化过程中，Spring会自动解析对象之间的依赖关系，并进行相应的注入。

通过依赖注入，可以使对象之间的解耦，提高代码的可维护性和可测试性。

初始化阶段：在初始化阶段，Spring框架会自动调用对象的初始化方法，以及执行一些额外的操作，如属性的赋值和事件的处理等。

在对象初始化的过程中，可以通过自定义的初始化方法来完成一些特殊的操作，如数据库连接的初始化、数据的加载等。

同时，Spring还提供了一些AOP（面向切面编程）的支持，可以在此阶段进行一些切面的处理，如日志记录、事务管理等。

使用阶段：在使用阶段，Spring框架会将已经初始化的对象注入到相应的调用者中，以供应用程序进行使用。

通过依赖注入，可以避免硬编码，动态地替换对象的实现，提高系统的灵活性和扩展性。

在使用阶段，Spring还提供了一些辅助工具，如AOP代理、数据库事务等，来帮助开发者更加方便地进行开发。

同时，Spring还提供了一些集成的支持，如与Web容器的集成、与数据源的集成等，可以帮助用户快速进行应用开发。

总结：Spring框架的执行流程可以描述为：配置阶段、实例化阶段、初始化阶段和使用阶段。

在配置阶段，Spring框架解析应用程序的配置信息；在实例化阶段，Spring框架创建对象的实例，并进行依赖注入；在初始化阶段，Spring框架调用对象的初始化方法，执行一些额外的操作；在使用阶段，Spring框架将对象注入到相应的调用者中，以供应用程序使用。

Spring教程(完整版)

第一章
Spring 简介
目标
• 理解什么是Spring • 理解Spring的用途
Spring简介
• Spring是一个开源框架，它的目的是为了简化企业级系统开发而诞生的
• Spring从小里说，是个容器，往大里说，就是个框架
• Spring是轻量级的，它的Jar包只有1M多一点，而且，它是非侵入式的：你一般不需要在你的类里import它的包
Servlet A Web容器
消息服务 LDAP
除此之外，应用程
序里还需要经常访
问一些服务，每种
服务的访问方式、
DB
方法是不一样的
客户端
这就是框架
Web容器
Spring框架日志
事务处理异常处理
国际化
验证 Servlet A 处理请求参数
业务逻辑实现 A
客户端
消息服务
LDAP
DB
Web
Service
Struts框架国际化
Servl验et证A 处理请求参数
业务逻辑实现 A
客户端
消息服务
LDAP
DB
ቤተ መጻሕፍቲ ባይዱ
Web
Service
Spring可以集成Hibernate
Web容器
Spring框架日志
事务处理异常处理
Struts框架国际化
Servl验et证A 处理请求参数
业务逻辑实现 A
Hibernat框架
Framework的定义
• 框架不仅要负责管理某些Bean的生命周期（容器的功能），还需要负责搭建某些基础设施（那些通用的部分）
• 例如：Struts能够称之为一个框架，是因为它负责管理Action ActionForm ActionForward这些对象的生命周期；另外它提供了国际化、异常处理、自动包装表单请求、验证等通用的功能

SpringFramework5.0入门教程

SpringFramework5.0⼊门教程1. 为什么学习Spring?随着对Java EE的不断接触和理解，你会发现Spring 在各个企业和项⽬中发挥着越来越重要的作⽤。

掌握Spring 已成为我们IT ⾏业⽣存必学的本领之⼀。

1. Spring Framework 是⼀个开源的Java／Java EE全功能栈（full-stack）的应⽤程序框架，以Apache许可证形式发布，也有.NET平台上的移植版本。

2. 该框架基于 Expert One-on-One Java EE Design and Development（ISBN 0-7645-4385-7）⼀书中的代码，最初由RodJohnson和Juergen Hoeller等开发。

3. Spring Framework提供了⼀个简易的开发⽅式，这种开发⽅式，将避免那些可能致使底层代码变得繁杂混乱的⼤量的属性⽂件和帮助类。

Spring Framework 当前最新版本是Spring Framework 5,当你打开官⽹，你应该能够看到官⽹的宣传图⽚这⾥有个相关的新闻有兴趣可以看下，中⽂版点击查看根据官⽹动态和我所了解的信息来看，Spring 官⽹还会继续⽀持Spring MVC，因为它还有很多改进的地⽅。

但是未来的趋势我认为必将是Spring Boot+ SpringWeb Flux + Spring Cloud .那么Spring MVC 和 Spring Web Flux 两者有何区别呢？官⽹对此给出了这样⼀张对⽐图：翻译下就是：1. Spring MVC基于servlet API构建，并使⽤⼀个同步阻塞I / O体系结构和⼀个单线程请求线程模型的Web 框架2. Spring WebFlux是⼀个⾮阻塞的Web框架，从该组建⽴起，利⽤多核，下⼀代处理器和⼤量并发连接。

总结：1. Spring MVC 是基于Servlet API 构建的同步阻塞式I/O 的Web 框架。

超详细的SpringBoot框架入门教程

超详细的SpringBoot框架⼊门教程Spring Boot 框架快速⼊门教程以⼤量⽰例讲解了 Spring Boot 在各类情境中的应⽤，让⼤家可以跟着⽼师的思维和代码快速理解并掌握。

适⽤于 Java 开发⼈员，尤其是初学 Spring Boot 的⼈员和需要从传统 Spring 转向 Spring Boot 开发的技术⼈员。

下边是动⼒节点的SpringBoot教程⾮常适合初学⼊门，讲的⾮常详细，⽽且全程⽆废话！视频链接：1. Spring Boot简介Spring 诞⽣时是 Java 企业版（Java Enterprise Edition，JEE，也称 J2EE）的轻量级代替品。

⽆需开发重量级的 Enterprise JavaBean（EJB），Spring 为企业级Java 开发提供了⼀种相对简单的⽅法，通过依赖注⼊和⾯向切⾯编程，⽤简单的Java 对象（Plain Old Java Object，POJO）实现了 EJB 的功能。

虽然 Spring 的组件代码是轻量级的，但它的配置却是重量级的。

第⼀阶段：xml配置在Spring 1.x时代，使⽤Spring开发满眼都是xml配置的Bean，随着项⽬的扩⼤，我们需要把xml配置⽂件放到不同的配置⽂件⾥，那时需要频繁的在开发的类和配置⽂件之间进⾏切换第⼆阶段：注解配置在Spring 2.x 时代，随着JDK1.5带来的注解⽀持，Spring提供了声明Bean的注解（例如@Component、@Service），⼤⼤减少了配置量。

主要使⽤的⽅式是应⽤的基本配置（如数据库配置）⽤xml，业务配置⽤注解第三阶段：java配置Spring 3.0 引⼊了基于 Java 的配置能⼒，这是⼀种类型安全的可重构配置⽅式，可以代替 XML。

我们⽬前刚好处于这个时代，Spring4.x和Spring Boot都推荐使⽤Java配置。

所有这些配置都代表了开发时的损耗。

Spring装配Bean教程之XML安装配置bean详解

Spring装配Bean教程之XML安装配置bean详解前⾔众所周知在Spring刚出现的时候，XML是描述配置的主要⽅式，在Spring的名义下，我们创建了⽆数⾏XML代码。

在⼀定程度上，Spring成为了XML的同义词。

现在随着强⼤的⾃动化配置和Java代码的配置出现，XML不再是唯⼀选择，也不应该是⾸选，学习XML配置，更多⽤于维护已有的XML的配置。

下⾯话不多说了，来⼀起看看详细的介绍吧。

创建XML配置规范在使⽤XML配置前，需要创建⼀个新的配置规范，就像JavaConfig需要我们创建带有 @Configuration注解的类，⽽在XML配置中，需要创建⼀个新的XML配置⽂件，并且要以<beans>元素为根。

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans";xmlns:xsi="/2001/XMLSchema-instance";xmlns:context="/schema/context";xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context"></beans>可以看出基本的XML配置就已经⽐JavaConfig复杂很多。

⽤来装配bean的最基本的XML元素包含在spring-beans模式中，在上⾯这个XML⽂件中，它被定义为根命名空间。

<beans>是该模式中过的⼀个元素，它是所有Spring配置⽂件的根元素。

声明⼀个简单的<bean>使⽤spring-beans模式中的另外⼀个元素：<bean>，该元素类似于JavaConfig中的 @Bean注解。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Spring教程Spring教程 (1)Spring框架概述 (3)Spring是什么？ (3)Spring的历史 (4)Spring的使命（Mission Statement） (4)Spring受到的批判 (4)Spring包含的模块 (4)总结 (6)Spring的IoC容器 (6)用户注册的例子 (7)面向接口编程 (8)（用户持久化类）重构第一步——面向接口编程 (8)重构第二步——工厂（Factory）模式 (9)重构第三步——工厂（Factory）模式的改进 (10)重构第四步－IoC容器 (10)控制反转（IoC）/依赖注入（DI） (11)什么是控制反转/依赖注入？ (11)依赖注入的三种实现形式 (12)BeanFactory (14)BeanFactory管理Bean（组件）的生命周期 (14)Bean的定义 (15)Bean的之前初始化 (18)Bean的准备就绪（Ready）状态 (21)Bean的销毁 (21)ApplicationContext (21)Spring的AOP框架 (21)Spring的数据层访问 (21)Spring的声明式事务 (21)Spring对其它企业应用支持 (21)名词解释容器：框架：组件：服务：Spring框架概述主要内容：介绍Spring的历史，Spring的概论和它的体系结构，重点阐述它在J2EE中扮演的角色。

目的：让学员全面的了解Spring框架，知道Spring框架所提供的功能，并能将Spring 框架和其它框架（WebWork/Struts、hibernate）区分开来。

Spring是什么？Spring是一个开源框架，它由Rod Johnson创建。

它是为了解决企业应用开发的复杂性而创建的。

Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。

然而，Spring 的用途不仅限于服务器端的开发。

从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

☐目的：解决企业应用开发的复杂性☐功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能☐范围：任何Java应用简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

■轻量——从大小与开销两方面而言Spring都是轻量的。

完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。

并且Spring所需的处理开销也是微不足道的。

此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

■控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。

当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。

你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

■面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。

应用对象只实现它们应该做的——完成业务逻辑——仅此而已。

它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

■容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean 可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。

然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

■框架——Spring可以将简单的组件配置、组合成为复杂的应用。

在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。

Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。

它们也为Spring中的各种模块提供了基础支持。

Spring的历史Spring的基础架构起源于2000年早期，它是Rod Johnson在一些成功的商业项目中构建的基础设施。

在2002后期，Rod Johnson发布了《Expert One-on-One J2EE Design and Development》一书，并随书提供了一个初步的开发框架实现——interface21开发包，interface21就是书中阐述的思想的具体实现。

后来，Rod Johnson 在interface21 开发包的基础之上，进行了进一步的改造和扩充，使其发展为一个更加开放、清晰、全面、高效的开发框架——Spring。

2003年2月Spring框架正式成为一个开源项目，并发布于SourceForge中。

Spring的使命（Mission Statement）☐J2EE应该更加容易使用。

☐面向对象的设计比任何实现技术（比如J2EE）都重要。

☐面向接口编程，而不是针对类编程。

Spring将使用接口的复杂度降低到零。

（面向接口编程有哪些复杂度？）☐代码应该易于测试。

Spring框架会帮助你，使代码的测试更加简单。

☐JavaBean提供了应用程序配置的最好方法。

☐在Java中，已检查异常（Checked exception）被过度使用。

框架不应该迫使你捕获不能恢复的异常。

Spring受到的批判Spring不是一个“标准”。

Spring不是J2EE规范的一部分，没有通过JCP（Java Community Process）的审核认可。

批判来源于EJB的支持者，他们认为EJB是一个标准，是J2EE规范的一部分。

当然，标准最主要的目的是希望在应用服务器之间是可移植的，可是EJB的移植却并不轻松，不同应用服务器的ejb部署描述文件总是有着差异。

而且EJB开发的类完全依赖于EJB容器。

而Spring对其管理的Bean没有任何形式的侵入，这样的Bean是普通Java 对象(POJO)，那么它就遵循Java标准，可以到处移植。

Spring是“超重量级”的。

Spring涉及的内容确实很多（例如：提供了对jdbc、ORM、远程访问等等的支持），但其本质还是Java技术的庞大。

Spring只是为了这些技术提供更好的使用方案而已。

同时，你可以只选取你需要使用的部分。

Spring包含的模块Spring框架由七个定义明确的模块组成（图1.1）。

（Spring框架概览图）如果作为一个整体，这些模块为你提供了开发企业应用所需的一切。

但你不必将应用完全基于Spring框架。

你可以自由地挑选适合你的应用的模块而忽略其余的模块。

就像你所看到的，所有的Spring模块都是在核心容器之上构建的。

容器定义了Bean是如何创建、配置和管理的——更多的Spring细节。

当你配置你的应用时，你会潜在地使用这些类。

但是作为一名开发者，你最可能对影响容器所提供的服务的其它模块感兴趣。

这些模块将会为你提供用于构建应用服务的框架，例如AOP和持久性。

核心容器这是Spring框架最基础的部分，它提供了依赖注入（Dependency Injection）特征来实现容器对Bean的管理。

这里最基本的概念是BeanFactory，它是任何Spring应用的核心。

BeanFactory是工厂模式的一个实现，它使用IoC将应用配置和依赖说明从实际的应用代码中分离出来。

应用上下文（Context）模块核心模块的BeanFactory使Spring成为一个容器，而上下文模块使它成为一个框架。

这个模块扩展了BeanFactory的概念，增加了对国际化（I18N）消息、事件传播以及验证的支持。

另外，这个模块提供了许多企业服务，例如电子邮件、JNDI访问、EJB集成、远程以及时序调度（scheduling）服务。

也包括了对模版框架例如V elocity和FreeMarker集成的支持。

Spring的AOP模块Spring在它的AOP模块中提供了对面向切面编程的丰富支持。

这个模块是在Spring应用中实现切面编程的基础。

为了确保Spring与其它AOP框架的互用性，Spring的AOP支持基于AOP联盟定义的API。

AOP联盟是一个开源项目，它的目标是通过定义一组共同的接口和组件来促进AOP的使用以及不同的AOP实现之间的互用性。

通过访问他们的站点http://aopalliance. ，你可以找到关于AOP联盟的更多内容。

Spring的AOP模块也将元数据编程引入了Spring。

使用Spring的元数据支持，你可以为你的源代码增加注释，指示Spring在何处以及如何应用切面函数。

JDBC抽象和DAO模块使用JDBC经常导致大量的重复代码，取得连接、创建语句、处理结果集，然后关闭连接。

Spring的JDBC和DAO模块抽取了这些重复代码，因此你可以保持你的数据库访问代码干净简洁，并且可以防止因关闭数据库资源失败而引起的问题。

这个模块还在几种数据库服务器给出的错误消息之上建立了一个有意义的异常层。

使你不用再试图破译神秘的私有的SQL错误消息！另外，这个模块还使用了Spring的AOP模块为Spring应用中的对象提供了事务管理服务。

对象/关系映射集成模块对那些更喜欢使用对象/关系映射工具而不是直接使用JDBC的人，Spring提供了ORM 模块。

Spring并不试图实现它自己的ORM解决方案，而是为几种流行的ORM框架提供了集成方案，包括Hibernate、JDO和iBA TIS SQL映射。

Spring的事务管理支持这些ORM框架中的每一个也包括JDBC。

Spring的W eb模块Web上下文模块建立于应用上下文模块之上，提供了一个适合于Web应用的上下文。

另外，这个模块还提供了一些面向服务支持。

例如：实现文件上传的multipart请求，它也提供了Spring和其它Web框架的集成，比如Struts、WebWork。

Spring的MVC框架Spring为构建Web应用提供了一个功能全面的MVC框架。

虽然Spring可以很容易地与其它MVC框架集成，例如Struts，但Spring的MVC框架使用IoC对控制逻辑和业务对象提供了完全的分离。

它也允许你声明性地将请求参数绑定到你的业务对象中，此外，Spring的MVC框架还可以利用Spring的任何其它服务，例如国际化信息与验证。

总结Spring带来了复杂的J2EE开发的春天。

它的核心是轻量级的IoC容器，它的目标是为J2EE应用提供了全方位的整合框架，在Spring框架下实现多个子框架的组合，这些子框架之间可以彼此独立，也可以使用其它的框架方案加以代替，Spring希望为企业应用提供一站式（one-stop shop）的解决方案。