如何使用Spring

合集下载

SpringMVC+Spring+Hibernate框架整合原理,作用及使用方法

SpringMVC+Spring+Hibernate框架整合原理,作⽤及使⽤⽅法SSM框架是spring MVC ，spring和mybatis框架的整合，是标准的MVC模式，将整个系统划分为表现层，controller层，service层，DAO层四层使⽤spring MVC负责请求的转发和视图管理spring实现业务对象管理，mybatis作为数据对象的持久化引擎原理：SpringMVC：1.客户端发送请求到DispacherServlet（分发器）2.由DispacherServlet控制器查询HanderMapping，找到处理请求的Controller3.Controller调⽤业务逻辑处理后，返回ModelAndView4.DispacherSerclet查询视图解析器，找到ModelAndView指定的视图5.视图负责将结果显⽰到客户端Spring：我们平时开发接触最多的估计就是IOC容器，它可以装载bean（也就是我们中的类，当然也包括service dao⾥⾯的），有了这个机制，我们就不⽤在每次使⽤这个类的时候为它初始化，很少看到关键字new。

另外spring的aop，事务管理等等都是我们经常⽤到的。

Mybatis：mybatis是对jdbc的封装，它让数据库底层操作变的透明。

mybatis的操作都是围绕⼀个sqlSessionFactory实例展开的。

mybatis通过配置⽂件关联到各实体类的Mapper⽂件，Mapper⽂件中配置了每个类对数据库所需进⾏的sql语句映射。

在每次与数据库交互时，通过sqlSessionFactory拿到⼀个sqlSession，再执⾏sql命令。

使⽤⽅法：要完成⼀个功能：1. 先写实体类entity，定义对象的属性，（可以参照数据库中表的字段来设置，数据库的设计应该在所有编码开始之前）。

2. 写Mapper.xml（Mybatis），其中定义你的功能，对应要对数据库进⾏的那些操作，⽐如 insert、selectAll、selectByKey、delete、update等。

Spring基本应用ppt课件

5
17.2 了解Spring的核心机制：依赖注入/控制反转
Spring的核心机制就是IoC（控制反转）容器，IoC的另外一个称呼是依赖注入（DI）。通过依赖注入，Java EE应用中的各种组件不需要以硬编码的方法进行耦合，当一个Java实例需要其他Java实例时，系统自动提供需要的实例，无需程序显式获取。因此，依赖注入实现了组件之间的解耦。
7
17.3 小结
本章主要介绍了使用Spring框架进行逻辑层开发的基本知识，先通过一个简单的Hello World示例演示Spring框架的简单应用；再以一个简单的登录验证为例，讲述了Spring的核心机制：依赖注入/控制反转。
8
3
17.1 认识Spring框架
Spring框架（Spring Framework）不断在发展和完善，但基本与核心的部分已经相当稳定，包括Spring的依赖注入容器、 AOP实现和对持久层的支持。
4
17.1 认识Spring框架
下面通过示例演示Spring框架的简单应用，步骤如下所示：
(1) 创建一个名为“spring_1”的Java项目，在项目中新建文件夹“lib”，用于存放项目所需的jar包。 (2) 从Spring官方网站下载Spring，以spring-framework-4.3.5.RELEASEdist.zip为例，解压后将其libs目录下的spring-beans-4.3.5.RELEASE.jar、 spring-context-4.3.5.RELEASE.jar、spring-core-4.3.5.RELEASE.jar和 spring-expression-4.3.5.RELEASE.jar这四个文件复制到项目spring-1的lib 目录中，即完成了Spring的安装。 (3) 将Spring依赖的日志包commons-logging-1.1.3.jar也复制到lib目录中。 (4) 选中该项目lib目录下的所有jar包，右击并选择“Build Path” “Add to Build Path”命令，将这些jar包添加到项目的构建路径中。 (5) 在spring_1项目中创建com.shw包，在包中新建名为“HelloWorld”的类。 (6) 在项目src目录下创建applicationContext.xml文件 (7) 在com.shw包中创建测试类TestHelloWorld，加载 applicationContext.xml配置文件，获取HelloWorld类的实例，然后调用类中的show()方法在控制台输出信息。 (8) 执行测试类TestHelloWorld，观察控制台倡面向接口的编程，依赖注入的基本思想是：明确地定义组件接口，独立开发各个组件，然后根据组件的依赖关系组装运行。

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框架的使用和管理软件开发中的Spring框架是一个广泛使用的框架，被许多开发者视为最重要的框架之一。

它提供了一种易于使用的方法来构建企业级应用程序，并且在可维护性、可测试性和可扩展性方面都表现出色。

从本文开始，我们将讨论如何在软件开发中使用和管理Spring框架。

一、Spring框架简介Spring框架是一个开源框架，提供了许多Java开发任务中常见的功能。

它可以轻松地实现依赖注入和控制反转，从而使开发者能够轻松地编写更灵活、更可维护的应用程序。

同时，Spring框架还提供了一系列的上下文支持，包括Web上下文支持、JDBC 支持、事务管理支持等。

这些支持使得Spring框架可以轻松地与其他常见技术如Hibernate、MyBatis等框架集成使用。

二、Spring框架的核心组件Spring框架有很多核心组件，其中最常用的是Spring核心容器、AOP(面向切面编程)模块和Spring MVC模块。

Spring核心容器允许开发者创建不同类型的对象并管理这些对象的生命周期。

该容器主要包含了BeanFactory和ApplicationContext两个容器。

其中，BeanFactory容器是Spring框架最基本的容器，主要用于创建和管理对象。

而ApplicationContext容器则是在BeanFactory之上构建而成，它提供了更加方便的实现，并且额外提供了在不同的上下文环境组件的方式。

AOP模块是Spring框架的另一个重要组件，它使得开发者可以通过把特定的代码切分成易于理解的部分(切面)，从而更加简单地管理代码。

对于需要在多个应用程序层面上实现一些功能的开发者来说，AOP模块提供了一个妙手的解决方案。

最后，Spring MVC是用于创建Web应用程序的模块。

通过使用Spring MVC，开发者可以快速地创建一个Web应用程序，并且可以很容易地扩展和维护这个应用程序。

【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();}}--测试结果，如果可以调⽤服务⽅法，测试成功。

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(){/*** 得到某个特定类型的集合。

项目中需要用到spring 的地方

如何实现批量更新：HibernateTemplate的bulkUpdate方法可以用hql语句直接进行批量更新
对结果列表进行加工：不论通过jdbc还是hibernate方式，如果需要对find方法取得的列表中的对象进行加工，显然使用回调模式进行效率更高。实际上如果使用HibernateTemplate并且希望查询出的结果不是对象列表而是数组列表，那么也可以使用回调，如下：
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
另外在实际项目中有一个发现，在websphere6.0的容器下部署的web应用，使用websphere自带的数据库连接池，当spring事务配置为readOnly,在数据量比较大，并且有一定并发量时会导致websphere连接池抛出异常，并导致性能严重下降。去掉readOnly选项就恢复正常了，这种情况不容易在测试环境重现，因此只能去掉readOnly选项，发现去掉以后性能也没有太多的下降。
service端的框架支持：在serivce层通过ioc进行bean的管理配置，同时进行事务控制的定义。
aop：利用拦截器配置管理特性
jndi：利用spring的context组件对jndi进行定义，通常用于数据库连接池的配置和查找
其他：spring1.2版本的mvc组件是针对web端的应用框架，尽管理念非常oop，不过实际使用的时候确实不如struts2好使，spring 2.0以后的mvc据说有很大改进，以后有机会再用吧。另外spring的定时任务（job）也经常用到，后边会有提及。

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的RestTemplate使用指南

spring的RestTemplate使⽤指南前⾔：现在restful接⼝越来越⼴泛，⽽如今很多接⼝摒弃了传统的配置复杂的webService开发模式，在java领域只需要很简单的springMvc就可以声明为⼀个控制器，再加上service层，就可以直接操作数据库成为⼀个灵活的接⼝。

⽽我们请求接⼝的次数也会越来越多（最近我在和⼀个⼯具对接的时候，对⽅公司提供的接⼝全部由我们主动去调⽤），⼀般我们请求接⼝，都采⽤Apache Httpclient⼯具，这个⼯具稳定，既可以建⽴长连接，保持不错的性能，⽽它唯⼀的不⾜就是使⽤起来⿇烦多变，并且要很多层判断处理，今天我要谈的就是spring对httpClient的再封装⼯具类，restTemplate，采⽤模板模式抽象出来的⾼效⼯具。

有点类似于jdbcTemplate，今天我们就来⼀步步揭开它的使⽤⽅法本篇博客的⽬录⼀：restTemplate简介⼆：restTemplate配置三：restTemplat使⽤⽅法-restUtil四：使⽤⽰例五：总结⼀：restTemplate简介1.1：restTemplate的类结构可以看出它继承⾃HttpAccessor这个统⼀的处理器，然后再继承⾃InterceptingHttpAccessor，这个拦截转换器，最终RestTemplate实现了封装httpClient的模板⼯具类1.2：restTemplate的⽅法Spring⽤于同步客户端HTTP访问的中⼼类。

它简化了与HTTP服务器的通信，并执⾏RESTful原则。

它处理HTTP连接，使应⽤程序代码提供URL,使⽤可能的模板变量,并提取结果。

注意：默认情况下，RestTemplate依赖于标准的JDK来建⽴HTTP连接。

你可以切换使⽤不同的HTTP库，如Apache HttpComponents，Netty和OkHttp通过setRequestFactory属性。

Spring内置定时任务调度@Scheduled使用详解

Spring内置定时任务调度@Scheduled使⽤详解Spring提供了@Scheduled注解⽤于定时任务。

⼀、@Scheduled的基本使⽤启⽤调度⽀持：@EnableScheduling可以将@Scheduled注释与触发器元数据⼀起添加到⽅法中。

例如，以下⽅法每隔5秒调⽤⼀次，并具有固定的延迟，这意味着周期是从前⾯每次调⽤的完成时间开始计算的@Scheduled(fixedDelay=5000)public void doSomething() {// something that should execute periodically}如果需要固定速率执⾏，可以更改批注中指定的属性名。

以下⽅法每5秒调⽤⼀次（在每次调⽤的连续开始时间之间计算）@Scheduled(fixedRate=5000)public void doSomething() {// something that should execute periodically}对于固定延迟和固定速率任务，可以通过指⽰在⾸次执⾏⽅法之前要等待的毫秒数来指定初始延迟@Scheduled(initialDelay=1000, fixedRate=5000)public void doSomething() {// something that should execute periodically}如果简单的周期性调度不够表达，可以提供cron表达式。

例如，以下命令仅在⼯作⽇执⾏：@Scheduled(cron="*/5 * * * * MON-FRI")public void doSomething() {// something that should execute on weekdays only}实现SchedulingConfigurer接⼝，重写configureTasks⽅法：@Schedule注解的⼀个缺点就是其定时时间不能动态更改，它适⽤于具有固定任务周期的任务，若要修改任务执⾏周期，只能⾛“停服务→修改任务执⾏周期→重启服务”这条路。

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-expression简单使用

Spring 中表达式语⾔spring-expression 简单使⽤前⾔Spring Expression Language （简称 SpEL ）是⼀个⽀持查询和操作运⾏时对象导航图功能的强⼤的表达式语⾔，它的语法类似于传统 EL(如jsp 中的EL 表达式)，但提供额外的功能，最出⾊的就是函数调⽤和简单字符串的模板函数。

SpEL 作为Spring 框架的基础，但并不依赖于Spring 容器，可以独⽴使⽤。

简单使⽤引⼊maven 依赖简单字⾯量⽀持字符串，⽇期，数值(整型，浮点型，⼗六进制)，布尔等类型输出结果为变量引⽤通过#'变量名'的⽅式来使⽤变量<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.1.RELEASE</version></dependency>//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();//解析表达式并获取结果System.out.println(expressionParser.parseExpression("'hello'").getValue());System.out.println(expressionParser.parseExpression("123").getValue());System.out.println(expressionParser.parseExpression("12.34").getValue());System.out.println(expressionParser.parseExpression("10e2").getValue());System.out.println(expressionParser.parseExpression("true").getValue());System.out.println(expressionParser.parseExpression("new java.util.Date()").getValue());hello12312.341000.0trueSat Sep 25 19:39:38 CST 2021//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();//创建数据上下⽂StandardEvaluationContext evaluationContext = new StandardEvaluationContext();//设置变量evaluationContext.setVariable("a", 12);evaluationContext.setVariable("b", 34);evaluationContext.setVariable("c", 56);//解析表达式System.out.println(expressionParser.parseExpression("#a+#b-#c").getValue(evaluationContext));输出为-10对象的属性和⽅法定义⼀个普通beanpublic class User {private String name;public User(String name) { = name;}public void setName(String name) { = name;}public String getName() {return name;}}通过对象.属性的⽅式来引⽤//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();//创建数据上下⽂StandardEvaluationContext evaluationContext = new StandardEvaluationContext(); evaluationContext.setVariable("user", new User("lisi"));System.out.println(expressionParser.parseExpression("#").getValue(evaluationContext)); System.out.println(expressionParser.parseExpression("#user.getName()").getValue(evaluationContext));输出为lisilisi数组，集合，map//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();//创建数据上下⽂StandardEvaluationContext evaluationContext = new StandardEvaluationContext();//设置数组变量evaluationContext.setVariable("users", new User[]{new User("Tom")});//设置集合变量evaluationContext.setVariable("userList", Collections.singletonList(new User("Mary")));//设置map变量evaluationContext.setVariable("userMap", Collections.singletonMap("u123", new User("u123")));System.out.println(expressionParser.parseExpression("#users[0].name").getValue(evaluationContext)); System.out.println(expressionParser.parseExpression("#userList[0].name").getValue(evaluationContext)); System.out.println(expressionParser.parseExpression("#userMap['u123'].name").getValue(evaluationContext));输出为TomMaryu123普通⽅法调⽤和在Java中使⽤没有区别//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();System.out.println(expressionParser.parseExpression("'hello'.substring(2)").getValue());输出为llo操作符⽀持关系操作符(⼤于⼩于等于)，逻辑操作符(and or not)，算数操作符(加减乘除)//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();System.out.println(expressionParser.parseExpression("1 < 4").getValue());System.out.println(expressionParser.parseExpression("1 < 4 and 5 > 9 ").getValue());System.out.println(expressionParser.parseExpression("1 + 3 - 5").getValue());引⽤IOC容器中的bean定义bean的配置⽂件import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;@Configurationpublic class BeanConfig {@Beanpublic User user() {return new User("lisi");}}默认⽀持#{}的格式来引⽤bean//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();//创建数据上下⽂StandardEvaluationContext evaluationContext = new StandardEvaluationContext();//创建IOC容器上下⽂ApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);//创建bean表达式上下⽂BeanExpressionContext beanExpressionContext = new BeanExpressionContext((ConfigurableBeanFactory) context.getAutowireCapableBeanFactory(), null); evaluationContext.setRootObject(beanExpressionContext);//添加属性访问器从IOC容器中获取beanevaluationContext.addPropertyAccessor(new BeanExpressionContextAccessor());System.out.println(expressionParser.parseExpression("#{}", new TemplateParserContext()).getValue(evaluationContext));输出为lisi@Value注解我们在项⽬中很多地⽅都会⽤到@Value注解@Value("${name}")private String name;@Value("#{}")private String personName;解析@Value注解的过程就会使⽤到SpELpublic class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactoryimplements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {@Nullablepublic Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);try {Object shortcut = descriptor.resolveShortcut(this);if (shortcut != null) {return shortcut;}Class<?> type = descriptor.getDependencyType();Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);if (value != null) {//字符串类型就表⽰是@Value注解注⼊if (value instanceof String) {// 使⽤StringValueResolver处理${}占位符String strVal = resolveEmbeddedValue((String) value);BeanDefinition bd = (beanName != null && containsBean(beanName) ?getMergedBeanDefinition(beanName) : null);//处理bean表达式，#{}这种格式value = evaluateBeanDefinitionString(strVal, bd);}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());try {return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());}catch (UnsupportedOperationException ex) {// A custom TypeConverter which does not support TypeDescriptor resolution...return (descriptor.getField() != null ?converter.convertIfNecessary(value, type, descriptor.getField()) :converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));}}......}@Nullableprotected Object evaluateBeanDefinitionString(@Nullable String value, @Nullable BeanDefinition beanDefinition) { if (this.beanExpressionResolver == null) {return value;}Scope scope = null;if (beanDefinition != null) {String scopeName = beanDefinition.getScope();if (scopeName != null) {scope = getRegisteredScope(scopeName);}}return this.beanExpressionResolver.evaluate(value, new BeanExpressionContext(this, scope));}}默认使⽤的beanExpressionResolver为StandardBeanExpressionResolver。

实验4 Spring使用基础

实验4 Spring开发基础一、实验目的1.掌握Spring框架的概念、特点及结构。

2.学会利用MyEclipse开发Spring的过程和方法。

3.熟悉applicationContext.xml配置bean的方法。

4.掌握Spring框架的核心技术IoC（DI）、AOP。

二、实验步骤1.运行MyEclipse建立Web Project（File→New→Web Project），项目名称为ex1，如下图所示，单击Finish按钮完成项目创建。

2.右击项目名ex1，在快捷菜单中选择MyEclipse→Project Facets→InstallSpring Facet，单击Finish按钮，完成配置。

3.通过这些步骤，项目中增加了Spring 3.1.1库，项目src文件夹下添加了applicationContext.xml的配置文件。

请查看这些改变。

4.在项目的src文件夹下面建立test包，在该包下面建立Person接口，内含go方法，再建立类Student和Teacher，分别实现Person接口，代码如下：5.在applicationContext.xml中添加如下两个bean的定义：6.在包test中建立Test类，从应用程序上下文中获得对象，并调用对象方法，其中main方法的代码如下：7.运行主类Test，观察并分析运行结果。

8.通过Set方法注入依赖。

修改Student类和Teacher类，分别在其中添加私有字符串属性name和set、get方法（设置姓名，自动生成set、get方法）,Teacher 类可以不要getName方法，修改go方法，在输出原有字符串前增加name的输出，代码如下：9.修改applicationContext.xml中的两个bean元素，设置name属性值，修改如下：10.再次运行主类Test，观察并分析运行结果。

11.引用其他bean，在Spring容器中将bean注入需要调用的实例。

如何使用多个Spring的xml配置文件

如何使用多个Spring的xml配置文件(多模块配置)在用Struts Spring Hibernate进行项目团队开发的时候，我们每个开发人员可能都会用到spring的配置文件，如果我们每个开放人员都用同一个的话，这样会给项目开发带来一定的影响，不过大家不用急，Spring为我们提供了很好的方法，我们可以写多个xml文件，然后将每个文件引入进来就行了，话不多说了，马上开始！！方法一、在web.xml中定义 contextConfigLocation参数.spring会使用这个参数加载.所有”逗号”分割的xml.如果没有这个参数,spring默认加载WEB-INF/applicationContext.xml文件(我们现在将Spring配置文件都放在WEB-INF下面)<context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:conf/spring/applicationContext_core*.xml,classpath*:conf/spring/applicationContext_dict*.xml,classpath*:conf/spring/applicationContext_hibernate.xml,classpath*:conf/spring/applicationContext_staff*.xml,classpath*:conf/spring/applicationContext_security.xmlclasspath*:conf/spring/applicationContext_modules*.xmlclasspath*:conf/spring/applicationContext_cti*.xmlclasspath*:conf/spring/applicationContext_apm*.xml</param-value></context-param>contextConfigLocation 参数定义了要装入的 Spring 配置文件。

Java Spring框架的详细使用教程

Java Spring框架的详细使用教程Java Spring框架是一个轻量级的开源框架，用于简化Java应用程序的开发。

它提供了许多功能和组件，能够帮助开发人员快速构建可扩展、可维护的企业级应用程序。

本文将详细介绍Java Spring框架的使用，包括框架的特点、核心概念和常用模块的介绍。

Java Spring框架的特点1. 轻量级：Java Spring框架采用了基于POJO（普通Java对象）的开发模式，不依赖于任何特定的容器或服务器，因此非常轻量级。

2. 面向切面编程（AOP）：Java Spring框架支持面向切面编程，可以通过AOP来实现一些横切关注点，如事务管理、日志记录等。

3. 控制反转（IoC）：Java Spring框架采用了控制反转的设计模式，将对象的创建、管理和依赖关系的维护交给框架来处理，使得开发人员能够更专注于业务逻辑的实现。

4. 声明式事务管理：Java Spring框架提供了事务管理的功能，可以通过简单的配置来实现声明式的事务管理，而无需编写复杂的事务控制代码。

Java Spring框架的核心概念1. IoC容器：IoC容器是Java Spring框架的核心部分，它负责对象的创建和管理。

开发人员将对象的实例化和依赖关系的维护交给IoC容器来处理，从而实现了对象的解耦和配置的灵活性。

2. Bean：在Java Spring框架中，被IoC容器所管理的对象被称为Bean。

Bean可以通过注解或XML配置的方式进行定义和配置。

3. AOP：面向切面编程是Java Spring框架的一个重要特性，开发人员可以通过AOP将一些横切关注点（如日志、安全、事务等）从业务逻辑中剥离出来，并在需要的时候进行统一的管理。

4. MVC框架：Java Spring框架提供了一个基于MVC（Model-View-Controller）模式的Web框架，通过将请求、处理和响应分离，使得Web应用程序的开发更加模块化和灵活。

快速入门使用SpringBoot进行Java开发

快速入门使用SpringBoot进行Java开发第一章：引言SpringBoot是一个开源的Java开发框架，旨在简化Java应用程序的开发过程。

它基于Spring框架构建，并提供了很多便利的功能和工具，使Java开发变得更加高效和快速。

本章将介绍SpringBoot的背景和特点，并帮助读者建立对SpringBoot的初步认识。

第二章：环境准备在开始使用SpringBoot之前，首先需要准备好相应的开发环境。

本章将介绍如何安装Java开发工具包（JDK）和集成开发环境（IDE），以及如何配置和测试环境，确保开发环境的正常运行。

第三章：快速入门本章将带领读者通过一个简单的示例来快速入门使用SpringBoot进行Java开发。

首先，我们将创建一个空白的SpringBoot项目，并添加必要的依赖。

然后，我们将编写一个简单的控制器类，并配置相应的路由映射。

最后，我们将运行和测试我们的应用程序，确保一切正常。

第四章：Web开发SpringBoot提供了强大且简单易用的Web开发功能，可以轻松构建RESTful API和Web应用程序。

本章将介绍如何使用SpringBoot开发Web应用程序，并演示常见的Web开发技术和实践，如URL映射、HTTP请求处理、数据绑定、表单处理等。

第五章：数据库操作大多数Java应用程序都需要与数据库进行交互，进行数据的读取、写入和修改。

SpringBoot提供了多种数据库访问方式，并且对常见的数据库操作进行了封装和简化。

本章将介绍如何使用SpringBoot进行数据库操作，并演示常用的数据库访问技术，如JDBC、JPA和MyBatis。

第六章：缓存管理在高并发的应用场景下，为了提高系统的性能和响应速度，使用缓存是一个常见且有效的方式。

SpringBoot提供了丰富的缓存管理功能，包括内存缓存、分布式缓存等。

本章将介绍如何使用SpringBoot进行缓存管理，并演示基于Redis的缓存实践。

Spring注解之@FeignClient注解使用方法

Spring注解之@FeignClient注解使⽤⽅法声明接⼝时在代码中通过@Resource注⼊容器之后即可使⽤。

@FeignClient注解的常⽤属性如下：value/name：value和name的作⽤⼀样，⽤于指定FeignClient的名称；如果没有配置url，⽽且项⽬使⽤了Eureka、nacos或者ribbon，name属性会作为微服务的名称，⽤于服务发现。

反之，只是⼀个名称。

此属性和对应。

url：⼀般⽤于调试，作⽤是指定@FeignClient调⽤的API地址，⽽⾮从服务中⼼获取。

url和name都可以使⽤占位符，⽐如：@FeignClient(name = “",url="${your.feign.url}”)；decode404：当发⽣http 404错误时，如果该字段为true，会调⽤decoder进⾏解码；否则，抛出FeignException。

configuration：Feign配置类，作⽤是⾃定义Feign的Encoder、Decoder、LogLevel、Contract。

fallback：定义容错的处理类，当调⽤远程接⼝失败或超时时，会调⽤对应接⼝的容错逻辑，fallback指定的类必须实现@FeignClient 标记的接⼝。

fallbackFactory：⼯⼚类，⽤于⽣成fallback类实例，实现每个接⼝通⽤的容错逻辑，减少重复的代码。

path：定义当前FeignClient的统⼀前缀。

contextId：为某个接⼝设置单独的超时，与与config⾥的属性对应。

添加依赖和启动注解spring-boot-starter-parent版本是2.5.0，需要添加的maven坐标：<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-openfeign</artifactId><version>3.0.4-SNAPSHOT</version></dependency>添加启动注解：@SpringBootApplication@EnableFeignClients//添加这个注解public class XXXXApplication {public static void main(String[] args) {SpringApplication.run(XXXXApplication.class, args);}}沙场秋点兵⾸先，在yaml⽂件中配置常量self.github.url=https://，然后，创建接⼝类，此接⼝类定义了需要调⽤的⽬标服务中的⽅法，⽤Feign 官⽅⽂档中调⽤GitHub服务的例⼦来举例。

如何用Spring发送电子邮件

如何⽤Spring发送电⼦邮件⽬录简介普通邮件导⼊javax.mail依赖Spring配置类邮件配置：mail.properties测试基于thymeleaf模版的邮件导⼊thymeleaf-spring依赖Spring配置类中添加thymeleaf模板配置模版⽂件：/src/main/resources/templates/msg.html测试简介Spring基于javax.mail封装了⼀套⽤于发送电⼦邮件的API，位于org.springframework.mail包下，下⾯将介绍下发送普通⽂本邮件和基于thymeleaf模版的邮件。

普通邮件导⼊javax.mail依赖<dependency><groupId>com.sun.mail</groupId><artifactId>javax.mail</artifactId><version>1.6.2</version></dependency>Spring配置类@PropertySource(value="classpath:mail.properties")@Configurationpublic class SpringConfig {@AutowiredEnvironment environment;/*** Spring邮件配置*/@Beanpublic JavaMailSenderImpl javaMailSenderImpl(){JavaMailSenderImpl javaMailSenderImpl = new JavaMailSenderImpl();javaMailSenderImpl.setHost(environment.getProperty("mail.host"));javaMailSenderImpl.setUsername(environment.getProperty("ername"));javaMailSenderImpl.setPassword(environment.getProperty("mail.password"));javaMailSenderImpl.setDefaultEncoding(environment.getProperty("mail.encoding"));return javaMailSenderImpl;}}邮件配置：mail.properties#QQ邮箱发送邮件服务器mail.host=#QQ邮箱账户名ername=*************#QQ邮箱授权码，开启IMAP/SMTP服务时会⽣成mail.password=lrorsapyffcwbegg#邮件发送编码mail.encoding=UTF-8测试@RunWith(SpringRunner.class)@ContextConfiguration(classes=SpringConfig.class)public class MailTest {@Autowiredprivate JavaMailSenderImpl javaMailSenderImpl;@Testpublic void testSimpleMail() throws MessagingException{MimeMessage message = javaMailSenderImpl.createMimeMessage();//发送带附件和内联元素的邮件需要将第⼆个参数设置为trueMimeMessageHelper helper = new MimeMessageHelper(message, true);//发送⽅邮箱，和配置⽂件中的ername要⼀致helper.setFrom("*************");//接收⽅helper.setTo("*************");//主题helper.setSubject("邮件测试");//邮件内容helper.setText("<html><body><img src='cid:myphoto'></body></html>", true);//邮件内容内嵌的图⽚,addInline中的contentId要和邮件内容中的cid相对应FileSystemResource res = new FileSystemResource(new File("e:/yc/1.jpg"));helper.addInline("myphoto", res);//邮件附件FileSystemResource file = new FileSystemResource(new File("e:/yc/myphoto.zip"));helper.addAttachment("myphoto.zip", file);javaMailSenderImpl.send(message);}}基于thymeleaf模版的邮件导⼊thymeleaf-spring依赖<dependency><groupId>org.thymeleaf</groupId><artifactId>thymeleaf-spring4</artifactId><version>3.0.11.RELEASE</version></dependency>Spring配置类中添加thymeleaf模板配置@Beanpublic TemplateEngine emailTemplateEngine() {SpringTemplateEngine templateEngine = new SpringTemplateEngine();ClassLoaderTemplateResolver templateResolver = new ClassLoaderTemplateResolver(); templateResolver.setResolvablePatterns(Collections.singleton("*.html"));templateResolver.setPrefix("/templates/");templateResolver.setSuffix(".html");templateResolver.setTemplateMode(TemplateMode.HTML);templateResolver.setCharacterEncoding("UTF-8");templateResolver.setCacheable(false);templateEngine.addTemplateResolver(templateResolver);return templateEngine;}模版⽂件：/src/main/resources/templates/msg.html<!DOCTYPE html><html xmlns:th=""><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><style type="text/css">span{color:orange}</style></head><body><p>您好， <span th:text="${name}">xxx</span>，感谢您使⽤XXX服务，您正在进⾏邮箱验证，本次请求的验证码为：</p><p><span th:text="${validCode}">1111</span>(为了保障您帐号的安全性，请在1⼩时内完成验证。

使用Spring从YAML文件读取内容映射为Map方式

使⽤Spring从YAML⽂件读取内容映射为Map⽅式⽬录从YAML⽂件读取内容映射为MapSpring框架中的YAML⽂件从YAML⽂件内容注⼊Map@ConfigurationProperties与@Value配置⽂件yml中的map形式yml中的格式创建⼀个类引⽤打印从YAML⽂件读取内容映射为Map如何在Spring Boot中从YAML⽂件注⼊到Map。

⾸先，将对Spring框架中的YAML⽂件有⼀些了解。

然后，通过⼀个实际⽰例展⽰如何将YAML属性绑定到Map。

Spring框架中的YAML⽂件使⽤YAML⽂件存储外部配置数据是⼀种常见的做法。

基本上，Spring⽀持使⽤YAML⽂档作为属性的替代⽅法，并在后台使⽤对其进⾏解析。

看看典型的YAML⽂件是什么样的：server:port: 8090application:name: myapplicationurl: 从上⾯可以看出，YAML⽂件是不⾔⾃明的，更易于阅读。

实际上，YAML提供了⼀种简洁的⽅式来存储分层配置数据。

默认情况下，Spring Boot在应⽤程序启动时从application.properties或application.yml读取配置属性。

但是，我们可以使⽤@PropertySource加载⾃定义的YAML⽂件。

既然熟悉了什么是YAML⽂件，看看如何在Spring Boot中将YAML属性作为Map注⼊。

从YAML⽂件内容注⼊MapSpring Boot通过提供⼀个⽅便的注解@ConfigurationProperties，将数据的外部化提升到了⼀个新的⽔平。

引⼊此注解是为了轻松地将配置⽂件中的外部属性直接注⼊Java对象。

接下来将介绍如何使⽤@ConfigurationProperties注解将YAML属性绑定到bean类中。

⾸先，在application.yml中定义⼀些键值属性：server:application:name: InjectMapFromYAMLurl: http://injectmapfromyaml.devdescription: How To Inject a map from a YAML File in Spring Bootconfig:ips:- 10.10.10.10- 10.10.10.11- 10.10.10.12- 10.10.10.13filesystem:- /dev/root- /dev/md2- /dev/md4users:root:username: rootpassword: rootpassguest:username: guestpassword: guestpass其次，创建⼀个bean类MapServerProperties来封装将配置属性绑定到Maps的逻辑：@Configuration@ConfigurationProperties(prefix = "server")@Datapublic class MapServerProperties {private Map<String, String> application;private Map<String, List<String>> config;private Map<String, Credential> users;@Datapublic static class Credential {private String username;private String password;}}如上⾯所见，我们⽤@ConfigurationProperties装饰了MapServerProperties类。

Spring中如何使用自定义注解搭配@Import引入内外部配置并完成某一功能的启用

Spring中如何使⽤⾃定义注解搭配@Import引⼊内外部配置并完成某⼀功能的启⽤有些⽹站第⼀时间爬取了我的原创⽂章，并且没有注明出处，不得已在这⾥加上说明。

⽂章背景有⼀个封装 RocketMq 的 client 的需求，⽤来提供给各项⽬收、发消息，但是项⽬当中常常只使⽤收或者发消息的单⼀功能，⽽且不同的项⽬group等并不相同⽽且不会变化，可以在项⽬当中配置，其余的topic等配置信息因有变动则迁移到配置中⼼去，因此萌⽣了如下想法提供⼀个⾃定义注解来启⽤收、发消息其中之⼀或者全部的公共组件研究之后，决定采⽤@Import来实现该功能⼀、Java注解的简单介绍注解，也叫Annotation、标注，是 Java 5 带来的新特性。

1. 可使⽤范围类、字段、⽅法、参数、构造函数、包等，具体可参阅枚举类ng.annotation.ElementType2. ⽣命周期（摘⾃）RetentionPolicy.SOURCE注解只保留在源⽂件，当Java⽂件编译成class⽂件的时候，注解被遗弃RetentionPolicy.CLASS注解被保留到class⽂件，但 jvm 加载class⽂件时候被遗弃，这是默认的⽣命周期RetentionPolicy.RUNTIME注解不仅被保存到class⽂件中，jvm 加载class⽂件之后，仍然存在3. 使⽤⽅式可以使⽤反射获取注解的内容，具体如何使⽤请⾃⼰百度，可参考这篇，这⾥不是重点，不多做介绍⼆、Spring的@Import注解@Import注解是Spring⽤来注⼊ Spring Bean 的⼀种⽅式，可以⽤来修饰别的注解，也可以直接在Springboot配置类上使⽤。

它只有⼀个value属性需要设置，来看⼀下源码public @interface Import {Class<?>[] value();}这⾥的 value属性只接受三种类型的Class：被@Configuration修饰的配置类接⼝org.springframework.context.annotation.ImportBeanDefinitionRegistrar的实现类接⼝org.springframework.context.annotation.ImportSelector的实现类下⾯针对三种类型的 Class 分别做简单介绍，⽂章后⾯有⾃定义注解与外部配置的结合使⽤⽅式。

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

如何使用Spring “依赖注入”问题我们要开发一个打印机模拟程序，（1）可以灵活地配置使用彩色墨盒还是灰色墨盒。

（2）可以灵活地配置打印页面的大小。

运行效果如图8.7所示。

图8.7 打印程序运行效果分析程序中包括打印机（Printer ）、墨盒（Ink ）和纸张（Pager ）3个组件。

打印机依赖墨盒和纸张。

我们采取如下的步骤开发这个程序。

（1）定义Ink 和Pager 的接口。

（2）使用Ink 和Pager 的接口开发Printer 程序。

在开发Printer 时并不依赖Ink 和Pager的实现类。

（3）开发Ink 和Pager 的实现类：ColorInk 、GreyInk 和TextPager 。

（4）组装打印机，运行调试。

1、定义Ink 和Paper 接口示例1package y2ssh.sg.chp8.di.ink; /*** 墨盒接口* @author 北大青鸟 */public interface Ink {public String getColor(int r,int g,int b); }Ink 接口只定义一个getColor 接口，传入红绿蓝三色的值，表示逻辑颜色；返回一个形如#ffc800的颜色字符串，表示打印采用的颜色。

配置为使用greyInk 、配置为使用colorInk 、示例2package y2ssh.sg.chp8.di.paper;/*** 纸张接口* @author 北大青鸟*/public interface Paper {public static final String newline = "\r\n";/*** 输出字符到纸张*/public void putInChar(char c);/*** 得到输出到纸张上的内容*/public String getContent();}Pager接口中定义了两个方法，putInChar用于向纸张中输出一个字符，向纸张输入字符后，纸张会根据自身大小（每页行数和每行字数的限制）在输入流中插入换行符、分页符和页码；getContent用于得到纸张中的现有内容。

2、使用Ink接口和Paper接口开发Printer示例3package y2ssh.sg.chp8.di;import y2ssh.sg.chp8.di.ink.Ink;import y2ssh.sg.chp8.di.paper.Paper;/*** 打印机程序* @author 北大青鸟*/public class Printer {public Ink ink = null;public Paper paper = null;public void print(String str){// 输出颜色标记System.out.println("使用"+ink.getColor(255, 200, 0)+"颜色打印:\n");// 逐字符输出到纸张for(int i=0;i<str.length();++i){paper.putInChar(str.charAt(i));}// 将纸张的内容输出System.out.print(paper.getContent());}}Printer类中只有一个print方法，输入参数是一个即将被打印的字符串，打印机将这个字符串逐个字符输入到纸张，然后将纸张中的内容输出。

在开发Printert程序的时候，我们只需要了解Ink和Paper接口即可，完全不依赖这些接口的实现。

设计硬盘的时候，设计师也只需要了解电源和数据接口的规范，不依赖具体的电源和主板的实现。

在设计真实的打印机的时候也是这样的，设计师也是针对纸张和墨盒的接口规范进行设计。

现在看示例3的程序。

print方法运行的时候去哪里获得ink和paper的实例呢？我们还需要提供“插槽”，以便组装的时候可以将ink和paper的实例“注入”进来，对Java 代码来说就是setter方法。

在示例3的Printer类代码中加入如示例4的两个setter方法，Printer 类的开发工作就完成了。

示例4public void setInk(Ink ink) {this.ink = ink;}public void setPaper(Paper paper) {this.paper = paper;}3、开发Ink和Paper的实现类：ColorInk、GreyInk和TextPaper示例5package y2ssh.sg.chp8.di.ink;import java.awt.Color;/*** 彩色墨盒* @author 北大青鸟*/public class ColorInk implements Ink {/* （非Javadoc）* @see com.aptech.jb.ink.Ink#getColor(int, int, int)*/public String getColor(int r, int g, int b) {Color color = new Color(r,g,b);return "#"+Integer.toHexString(color.getRGB()).substring(2);}}示例6package y2ssh.sg.chp8.di.ink;import java.awt.Color;public class GreyInk implements Ink{public String getColor(int r, int g, int b) {int c = (r+g+b)/3;Color color = new Color(c,c,c);return "#"+Integer.toHexString(color.getRGB()).substring(2);}}彩色墨盒的gerColor方法只是把传入的颜色参数做了简单的格式转换；灰色墨盒则先把传入的颜色值进行计算，转换成灰度颜色，再进行格式转换。

这不是我们关注的重点。

示例7package y2ssh.sg.chp8.di.paper;/*** 文本打印纸张实现* @author 北大青鸟*/public class TextPaper implements Paper {private int charPerLine = 16;//每行字符数private int linePerPage = 5;//每页行数private String content = "";//纸张中内容private int posX = 0;//当前横向位置，从0到charPerLine-1private int posY = 0;//当前行数，从0到linePerPage-1private int posP = 1;//当前页数/* （非Javadoc）* @see com.aptech.jb.Paper#getContent()*/public String getContent() {String ret = this.content;// 补齐本页空行，并显示页码if (!(posX==0 && posY==0)){int count = linePerPage - posY;for (int i=0;i<count;++i){ret += Paper.newline;}ret += "== 第"+posP+"页==";}return ret;}/* （非Javadoc）* @see com.aptech.jb.Paper#putInChar(char)*/public void putInChar(char c) {content += c;++posX;// 判断是否换行if (posX==charPerLine){content += Paper.newline;posX = 0;++posY;}// 判断是否翻页if (posY==linePerPage){content += "== 第"+posP+"页==";content += Paper.newline + Paper.newline;posY = 0;++posP;}}// Setter方法，用于属性注入。

public void setCharPerLine(int charPerLine) {this.charPerLine = charPerLine;}public void setLinePerPage(int linePerPage) {this.linePerPage = linePerPage;}}在TextPaper实现类的代码中，我们不用关心具体逻辑的实现。

其中content用于保存当前纸张的内容。

charPerLine和linePerPage用于限定每行可以打印多少个字符和每页可以打印多少行。

我们注意到setCharPerLine和setLinePerPage两个setter方法，跟示例4中的setter方法相同，这也是为了组装时“注入”数据留下的“插槽”。

所以，我们不仅可以注入某个类的实例，还可以注入数值、字符串等基本数据类型。

4、组装打印机，运行调试零件都准备好了，要开始组装啦！在前3步，我们都没有接触到Spring，只有从组装这一步，才开始设计Spring，首先，给项目添加Spring 支持。

右击项目节点，在弹出的右键菜单中选择“MyEclipse ”—“Add Spring Capabilities..”选项；或者选中项目节点，从菜单里选择“MyEclipsse ”—“Add Spring Capabilities..”选项。

添加Spring 支持成功后，MyEclipse 自动帮我们导入了Spring 1.2 Core Libraries 库，这个库支持“依赖注入”，还自动在src 目录下创建了applicationContect.xml 。

在这个文件上单击右键，在弹出的菜单中选择“重构”—“重命名”选项，将这个文件重命名为di.xml 。

打开di.xml ，组装的工作就在这个文件里完成。

起初，di.xml 的内容如示例8所示。

示例8<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "/dtd/spring-beans.dtd"> <beans></beans>首先，创建几个待组装零件的实例，如图8.10所示。