一、安装Spring IDE
在Eclipse Marketplace 查询安装Spring IDE。
二、导入Spring必须的jar包
使用maven管理spring的jar包。
<properties>
<spring.version>版本号</spring.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependencies>
三、Spring配置bean
配置bean的形式:基于xml文件的方式;基于注解的方式。
1. 基于xml配置bean
1.1 全类名配置bean
Person.java
package com.cd.spring.bean;
public class Person {
private String user;
// 必须有无参构造器
public Person() {
System.out.println("Person's constructor...");
}
public Person(String user) {
this.user = user;
}
public void setUser(String user) {
System.out.println("setUser:" + user);
this.user = user;
}
public void hello(){
System.out.println("Hello: " + user);
}
}
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
<!--
全类名配置一个 bean
在 IOC 容器中id必须是唯一的。
-->
<bean id="helloWorld" class="com.cd.spring.bean.Person">
<!-- 为属性赋值 -->
<property name="user" value="zhangsan"></property>
</bean>
</beans>
Main.java
package com.cd.spring.bean;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
// 创建 Spring 的 IOC 容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
// 从 IOC 容器中获取 bean 的实例
HelloWorld helloWorld = (HelloWorld) ctx.getBean("helloWorld");
// 根据类型来获取 bean 的实例: 要求在 IOC 容器中只有一个与之类型匹配的 bean, 若有多个则会抛出异常.
// 一般情况下, 该方法可用, 因为一般情况下, 在一个 IOC 容器中一个类型对应的 bean 也只有一个.
// HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
// 使用 bean
helloWorld.hello();
}
}
ps:
ApplicationContext 在初始化上下文时就实例化所有单例的 bean
1.2 工厂方法配置bean
1.2.1 静态工厂方法
静态工厂类示例:
StaticFactoryMethod.java
package com.cd.spring.factorybean;
import java.util.HashMap;
import java.util.Map;
public class StaticFactoryMethod {
public static Map<String,Person> map = new HashMap<String,Person>();
static {
map.put("first", new Person(1,"jayjay1"));
map.put("second", new Person(2,"jayjay2"));
}
public static Person getPerson(String key){
return map.get(key);
}
}
xml配置:
<!-- static factory method -->
<!-- factory-method: 指向静态工厂方法的名字-->
<bean id="person" factory-method="getPerson" class="com.cd.spring.factorybean.StaticFactoryMethod">
<constructor-arg value="first" type="java.lang.String"></constructor-arg>
</bean>
1.2.2 实例工厂方法
工厂类示例:
InstanceFactoryMethod.java
package com.cd.spring.factorybean;
import java.util.HashMap;
import java.util.Map;
// 实例工厂的方法
public class InstanceFactoryMethod {
public static Map<String, Person> map = null;
public InstanceFactoryMethod(){
map = new HashMap<String, Person>();
map.put("first", new Person(1,"jayjay1"));
map.put("second", new Person(2,"jayjay2"));
}
public Person getPerson(String key){
return map.get(key);
}
}
xml配置:
<!-- instance factory method -->
<bean id="InstanceFactoryMethod" class="com.cd.spring.factorybean.InstanceFactoryMethod"></bean>
<!--
factory-bean: 指向实例工厂方法的bean
factory-method: 指向静态工厂方法的名字
-->
<bean id="person1" factory-bean="InstanceFactoryMethod" factory-method="getPerson">
<constructor-arg value="second"></constructor-arg>
</bean>
1.3 FactoryBean配置bean
需要对FactoryBean接口的3个方法进行适当重写
PersonFactoryBean.java
package com.cd.spring.factorybean;
import org.springframework.beans.factory.FactoryBean;
public class PersonFactoryBean implements FactoryBean<Person>{
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private int id;
private String name;
@Override
public Person getObject() throws Exception {
return new Person(id,name);
}
@Override
public Class<?> getObjectType() {
return Person.class;
}
@Override
public boolean isSingleton() {
return false;
}
}
xml配置
<!-- use factory bean to get a instance -->
<bean id="person2" class="com.cd.spring.factorybean.PersonFactoryBean">
<property name="id" value="3"></property>
<property name="name" value="FactoryBean"></property>
</bean>
1.4 依赖注入的方式
1.4.1 属性注入
- 属性注入即通过 setter 方法注入bean 的属性值或依赖的对象
- 属性注入使用 <property> 元素, 使用 name 属性指定 bean 的属性名称,value 属性或 <value>子节点指定属性值
- 属性注入是实际应用中最常用的注入方式:
<bean id="helloWorld" class="com.cd.spring.bean.HelloWorld">
<!-- 为属性赋值 -->
<property name="user" value="zhangsan"></property>
</bean>
1.4.2 构造器注入
通过构造方法注入bean 的属性值或依赖的对象,它保证了 bean 实例在实例化后就可以使用。
构造器注入在 <constructor-arg> 元素里声明属性, <constructor-arg> 中没有 name 属性
<!-- 若一个 bean 有多个构造器, 如何通过构造器来为 bean 的属性赋值 -->
<!-- 可以根据 index 和 type 进行更加精确的定位. -->
<bean id="cal" class="com.cd.spring.bean.Calculator">
<constructor-arg value="200" index="1"></constructor-arg>
<constructor-arg value="100" index="0"></constructor-arg>
<constructor-arg value="300" type="float"></constructor-arg>
</bean>
1.5 字面值
- 字面值:可用字符串表示的值,可以通过 <value> 元素标签或 value 属性进行注入。
- 基本数据类型及其封装类、String 等类型都可以采取字面值注入的方式。
- 若字面值中包含特殊字符,可以使用 <![CDATA[]]>把字面值包裹起来。
1.6 引用其它bean
组成应用程序的 bean 经常需要相互协作以完成应用程序的功能. 要使 bean 能够相互访问, 就必须在 bean 配置文件中指定对 bean 的引用
在 bean 的配置文件中, 可以通过 <ref>元素或 ref 属性为 bean 的属性或构造器参数指定对 bean 的引用。
也可以在属性或构造器里包含 bean 的声明, 这样的 bean 称为内部 bean。
<!-- 配置 bean -->
<bean id="dao" class="com.cd.spring.Dao"></bean>
<bean id="service" class="com.cd.spring.Service">
<!-- 通过 ref 属性值指定当前属性指向哪一个 bean! -->
<property name="dao" ref="dao"></property>
</bean>
1.7 内部bean
当 bean 实例仅仅给一个特定的属性使用时, 可以将其声明为内部 bean. 内部 bean 声明直接包含在 <property> 或 <constructor-arg> 元素里, 不需要设置任何 id 或 name 属性
内部 bean 不能使用在任何其他地方。
<!-- 声明使用内部 bean -->
<bean id="service" class="com.cd.spring.Service">
<property name="dao">
<bean class="com.cd.spring.Dao">
<property name="dataSource" value="c3p0"></property>
</bean>
</property>
</bean>
1.8 集合属性
在 Spring中可以通过一组内置的 xml 标签(例如: <list>, <set> 或 <map>) 来配置集合属性.
1.8.1 List
- 配置 java.util.List 类型的属性, 需要指定 <list> 标签, 在标签里包含一些元素. 这些标签可以通过 <value> 指定简单的常量值, 通过 <ref> 指定对其他 bean 的引用. 通过
<!-- 装配List集合属性 -->
<bean id="user" class="com.cd.spring.bean.User">
<property name="userName" value="zhangsan"></property>
<property name="list">
<list>
<value>list1</value>
<value>list2</value>
<value>list3</value>
</list>
</property>
</bean>
1.8.2 Map
java.util.Map 通过 <map> 标签定义, <map> 标签里可以使用多个 <entry> 作为子标签. 每个条目包含一个键和一个值.
必须在 <key> 标签里定义键
因为键和值的类型没有限制, 所以可以自由地为它们指定 <value>, <ref>, <bean> 或 <null> 元素.
可以将 Map 的键和值作为 <entry> 的属性定义: 简单常量使用 key 和 value 来定义; bean 引用通过 key-ref 和 value-ref 属性定义
<!-- configure the map -->
<bean id="testMap" class="com.cd.spring.bean.User">
<property name="map">
<map>
<entry key="first" value="1"></entry>
<entry key="second" value="2"></entry>
<entry key="third" value="3"></entry>
</map>
</property>
</bean>
1.8.3 Properties
使用 <props> 定义 java.util.Properties, 该标签使用多个 <prop> 作为子标签. 每个 <prop> 标签必须定义 key 属性.
DataSource.java
package com.cd.spring.bean;
import java.util.Properties;
public class DataSource {
@Override
public String toString() {
return "Properties [properties=" + properties + "]";
}
public Properties getProperties() {
return properties;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
private Properties properties;
}
application.xml配置
<!-- configure the properties -->
<bean id="dataSource" class="com.cd.spring.bean.DataSource">
<property name="properties">
<props>
<prop key="user">root</prop>
<prop key="password">root</prop>
<prop key="jdbcUrl">jdbc:mysql:///test</prop>
<prop key="driverClass">com.mysql.jdbc.Driver</prop>
</props>
</property>
</bean>
1.9 util命名空间
通过xml的Namespaces导入util命名空间。
<!-- 声明集合类型的 bean,共享该集合 -->
<util:list id="users">
<ref bean="user0"/>
<ref bean="user1"/>
<ref bean="user2"/>
</util:list>
<bean id="Users" class="test.Spring.helloworld.Users">
<property name="list">
<ref bean="users"/>
</property>
</bean>
1.10 p命名空间
为了简化 XML 文件的配置,越来越多的 XML 文件采用属性而非子元素配置信息。
Spring 从 2.5 版本开始引入了一个新的 p 命名空间,可以通过 <bean> 元素属性的方式配置 bean 的属性。
通过xml的Namespaces导入p命名空间。
<bean id="user" class="com.cd.spring.bean.User" p:userName="zhangsan"></bean>
1.11 abstract模板bean
设置abstract=true表明此bean是模板bean,为其他bean提供属性值模板
<!-- template bean -->
<bean abstract="true" id="template" p:id="50" p:name="fromTemplate"></bean>
<bean id="user1" parent="template" class="com.cd.spring.bean.User"></bean>
1.12 单例bean和原型bean
<!-- use scope to build singleton/prototype bean -->
<bean id="user0" parent="template" scope="singleton" class="test.Spring.helloworld.User"></bean>
<bean id="user1" parent="template" scope="prototype" class="test.Spring.helloworld.User"></bean>
singleton:此bean为单例,在context创建时已经创建,并且只有一个实例。
prototype:当需要时创建实例。
1.13 导入资源文件
db.properties
jdbc.user=root
jdbc.password=root
jdbc.jdbcUrl=jdbc:mysql:///test
jdbc.driverClass=com.mysql.jdbc.Driver
xml配置
<context:property-placeholder location="classpath:db.properties"/>
<bean id="dataSource" class="com.cd.spring.bean.DataSource">
<property name="properties">
<props>
<prop key="user">${jdbc.user}</prop>
<prop key="password">${jdbc.password}</prop>
<prop key="jdbcUrl">${jdbc.jdbcUrl}</prop>
<prop key="driverClass">${jdbc.driverClass}</prop>
</props>
</property>
</bean>
2. 基于注解配置bean
加上注解的类会被Spring容器管理。
组件扫描(component scanning): Spring 能够从 classpath 下自动扫描, 侦测和实例化具有特定注解的组件.
2.1 常用注解
特定组件包括:
* @Component: 基本注解, 标识了一个受 Spring 管理的组件
* @Respository: 标识持久层组件
* @Service: 标识服务层(业务层)组件
* @Controller: 标识表现层组件
* @Autowired: 依据类型自动装配
* @Qualifier: 指定自动装载的bean的name
对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称。
xml配置:
在Spring配置文件中导入context命名空间,并加入。
<context:component-scan base-package="com.cd.spring.annotation"></context:component-scan>
ps:
base-package 属性指定一个需要扫描的基类包,Spring 容器将会扫描这个基类包里及其子包中的所有类.
当需要扫描多个包时, 可以使用逗号分隔.
如果仅希望扫描特定的类而非基包下的所有类,可使用 resource-pattern 属性过滤特定的类。如:resource-pattern=”autowire/*.class”
<context:include-filter>
子节点表示要包含的目标类,该子节点需要use-default-filters配合使用。
<context:exclude-filter>
子节点表示要排除在外的目标类。
2.2 示例
TestObject:
package com.nf.test.bean.annotation;
import org.springframework.stereotype.Component;
@Component
public class TestObject {
}
UserController.java
package com.cd.spring.annotation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import com.cd.spring.annotation.service;
@Controller
public class UserController {
@Autowired
private UserService userService;
public void execute() {
System.out.println("UserController execute...");
userService.add();
}
}
UserRepository.java
package com.cd.spring.annotation.repository;
public interface UserRepository {
void save();
}
UserRepositoryImpl.java
package com.cd.spring.annotation.repository;
import org.springframework.stereotype.Service;
import com.nf.test.bean.annotation.TestObject;
@Repository("userRepository")
public class UserRepositoryImpl implements UserRepository{
@Autowired(required=false)// 类型可以是非注解,不会异常
private TestObject testObject;
public void save(){
System.out.println("UserRepository save...");
System.out.println(testObject);
}
}
UserService.java
package com.cd.spring.annotation.service;
import org.springframework.stereotype.Service;
import com.cd.spring.annotation.repository.UserRepository;
@Service
public class UserService {
// @Autowired默认按类的名字(首字母小写)去匹配。
// 可以指定@Qualifier("userRepositoryImpl")设置匹配的类名。
@Autowired
private UserRepository userRepository;
public void add(){
System.out.println("add...");
userRepository.save();
}
}
xml配置:
<context:component-scan base-package="com.cd.spring.annotation">
</context:component-scan>
调用
ApplicationContext ctx = new ClassPathXmlApplicationContext("bean_annotation.xml");
UserController controller = (UserController)ctx.getBean("userController");
System.out.println(controller);
controller.execute();
2.3 泛型注入
示例:
BaseRepository.java
package com.cd.test.bean.generic.di;
public class BaseRepository<T> {
}
BaseService.java
package com.cd.test.bean.generic.di;
import org.springframework.beans.factory.annotation.Autowired;
public class BaseService<T> {
@Autowired
protected BaseRepository<T> repository;
public void add() {
System.out.println("add...");
System.out.println(repository);
}
}
package com.cd.test.bean.generic.di;
public class User {
}
package com.cd.test.bean.generic.di;
import org.springframework.stereotype.Repository;
@Repository
public class UserRepository extends BaseRepository<User>{
}
package com.cd.test.bean.generic.di;
import org.springframework.stereotype.Service;
@Service
public class UserService extends BaseService<User>{
}
xml配置:
<context:component-scan base-package="com.cd.test.bean.generic.di"></context:component-scan>
调用
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService)context.getBean("userService");
userService.add();
3. bean的生命周期
通过init-method 和 destory-method为bean指定初始化和销毁方法。
Person.java
package com.cd.spring.bean;
public class Person {
private String user;
public Person() {
System.out.println("Person's constructor...");
}
public Person(String user) {
this.user = user;
}
public void setUser(String user) {
System.out.println("setUser:" + user);
this.user = user;
}
public void init(){
System.out.println("init...");
}
public void destory(){
System.out.println("destory...");
}
}
xml配置
<bean id="person" class="com.cd.spring.bean.Person" init-method="init" destory-method="destory">
<property name="user" value="zhangsan"></property>
</bean>
bean的后置处理器。允许在调用初始化方法前后对 Bean 进行额外的处理。
MyBeanPostProcessor.java
package com.cd.spring.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPostProcessor implements BeanPostProcessor {
public MyBeanPostProcessor() {
super();
System.out.println("BeanPostProcessor实现类构造器!!");
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out
.println("postProcessAfterInitialization对属性进行更改!");
return bean;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
System.out
.println("postProcessBeforeInitialization对属性进行更改!");
return bean;
}
}
xml配置
<bean id="beanPostProcessor" class="com.cd.spring.bean.MyBeanPostProcessor">
</bean>