Spring IOC、DI、工厂、单例
Author：Exchanges
Version：9.0.2
一、引言
1.1 原生web开发中存在哪些问题？
传统Web开发存在硬编码所造成的过度程序耦合（例如：Service中作为属性Dao对象）。
部分Java EE API较为复杂，使用效率低（例如：JDBC开发步骤）。
侵入性强，移植性差（例如：DAO实现的更换，从Connection到SqlSession）。
二、Spring框架
2.1 概念
什么是Spring
Spring是分层的JavaSE/EE full-stack(一站式) 轻量级开源框架，以IOC（Inverse of Control 控制反转）和AOP（Aspect Oriented Programming 面向切面编程为内核）Spring是众多优秀设计模式的组合（工厂、单例、代理、适配器、包装器、观察者 ......）
分层:
JavaEE的三层结构:web层、业务层、数据访问层（持久层，集成层）
Struts2是web层基于MVC设计模式框架.
Mybatis，Hibernate是持久的一个ORM的框架.
一站式:
Spring框架有对三层的每层解决方案:
web层:Spring MVC.
持久层:JDBC Template （了解）
业务层:Spring的Bean管理Spring的好处：
方便解耦，简化开发
Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理
AOP编程的支持
Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
声明式事务的支持
只需要通过配置就可以完成对事务的管理，而无需手动编程
方便程序的测试
Spring对Junit4支持，可以通过注解方便的测试Spring程序
方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持
Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，降低JavaEE API的使用难度
2.2 访问与下载
官方网站：https://spring.io/
下载地址：http://repo.spring.io/release/org/springframework/spring/
三、Spring架构组成
Spring架构由诸多模块组成，可分类为
| Spring架构组成 |
|---|
 |
| GroupId | ArtifactId | 说明 |
|---|---|---|
| org.springframework | spring-beans | Beans 支持，包含 Groovy |
| org.springframework | spring-aop | 基于代理的AOP支持 |
| org.springframework | spring-aspects | 基于AspectJ 的切面 |
| org.springframework | spring-context | 应用上下文运行时，包括调度和远程抽象 |
| org.springframework | spring-context-support | 支持将常见的第三方类库集成到 Spring 应用上下文 |
| org.springframework | spring-core | 其他模块所依赖的核心模块 |
| org.springframework | spring-expression | Spring 表达式语言，SpEL |
| org.springframework | spring-instrument | JVM 引导的仪表（监测器）代理 |
| org.springframework | spring-instrument-tomcat | Tomcat 的仪表（监测器）代理 |
| org.springframework | spring-jdbc | 支持包括数据源设置和 JDBC 访问支持 |
| org.springframework | spring-jms | 支持包括发送/接收JMS消息的助手类 |
| org.springframework | spring-messaging | 对消息架构和协议的支持 |
| org.springframework | spring-orm | 对象/关系映射，包括对 JPA 和 Hibernate 的支持 |
| org.springframework | spring-oxm | 对象/XML 映射（Object/XML Mapping，OXM） |
| org.springframework | spring-test | 单元测试和集成测试支持组件 |
| org.springframework | spring-tx | 事务基础组件，包括对 DAO 的支持及 JCA 的集成 |
| org.springframework | spring-web | web支持包，包括客户端及web远程调用 |
| org.springframework | spring-webmvc | REST web 服务及 web 应用的 MVC 实现 |
| org.springframework | spring-webmvc-portlet | 用于 Portlet 环境的MVC实现 |
| org.springframework | spring-websocket | WebSocket 和 SockJS 实现，包括对 STOMP 的支持 |
| org.springframework | spring-jcl | Jakarta Commons Logging 日志系统 |
四、Spring入门
4.1 导入依赖
<!-- spring核心依赖 -->
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.20</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
4.2 创建表以及对应实体类
create table t_user(
id int primary key auto_increment,
name varchar(50),
password varchar(50)
)default charset = utf8;
INSERT INTO t_user(NAME,PASSWORD) VALUES("jack","123");
INSERT INTO t_user(NAME,PASSWORD) VALUES("tom","456");
INSERT INTO t_user(NAME,PASSWORD) VALUES("rose","789");
package com.qf.pojo;
/**
* User实体类
*/
public class User {
private Integer id;
private String name;
private String password;
public User() {
System.out.println("无参构造");
}
}
4.3 在\src\main\resources目录下创建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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
该id属性是标识单个 bean 定义的字符串。(不能重复)
该class属性定义 bean 的类型并使用完全限定的类名。
-->
<bean id="user" class="com.qf.pojo.User">
</bean>
</beans>
4.4 测试
package com.qf.test;
import com.qf.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* 测试类
*/
public class SpringTest {
@Test
public void testUser() {
//需要加载配置文件
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
//根据bean标签中的id属性值，获取bean对象
User user = (User)applicationContext.getBean("user");
System.out.println(user);
}
}
4.5BeanFactory与ApplicationContext区别
ApplicationContext:它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。
BeanFactory:它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。ApplicationContext对BeanFactory提供了扩展:
国际化处理
事件传递
Bean自动装配
各种不同应用层的Context实现
早期开发使用BeanFactory.
五、Spring对bean的管理细节
IOC：控制反转，将对象的创建权交给了Spring去管理
底层原理：反射 + 配置文件
5.1创建bean的方式
Bean元素:使用该元素描述需要spring容器管理的对象
class属性:被管理对象的完整类名.
name属性:给被管理的对象起个名字.获得对象时根据该名称获得对象.
id属性: 与name属性作用相同.
5.1.1第一种方式：使用默认构造函数创建。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
第一种方式：使用默认构造函数创建。
在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。
该id属性是标识单个 bean 定义的字符串。(不能重复)
该class属性定义 bean 的类型并使用完全限定的类名。
-->
<bean id="user" class="com.qf.pojo.User">
</bean>
</beans>
5.1.2第二种方式：使用工厂类通过反射创建。
创建工厂类
package com.qf.factory;
import com.qf.pojo.User;
/**
* 通过实例方法获取User对象
*/
public class UserFactory {
/**
* 获取 User 对象
* @return
*/
public User getUser() {
//return new User();
//反射 + 配置文件
try {
return (User)Class.forName("com.qf.pojo.User").newInstance();
} catch (Exception e) {
e.printStackTrace();
}
//return null;
//手动抛异常
throw new RuntimeException("创建User对象异常");
}
/**
* 通过静态方法获取 User 对象
* @return
*/
public static User getUserStatic() {
//return new User();
//反射 + 配置文件
try {
return (User)Class.forName("com.qf.pojo.User").newInstance();
} catch (Exception e) {
e.printStackTrace();
}
//return null;
//手动抛异常
throw new RuntimeException("创建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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
第一种方式：使用默认构造函数创建。
在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。
该id属性是标识单个 bean 定义的字符串。(不能重复)
该class属性定义 bean 的类型并使用完全限定的类名。
-->
<!-- <bean id = "user" class = "com.qf.pojo.User">-->
<!-- </bean>-->
<!-- 工厂中的实例方法创建Bean -->
<!-- <bean id = "userFactoryBean" class = "com.qf.factory.UserFactory"></bean>-->
<!-- <bean id = "user" factory-bean="userFactoryBean" factory-method="getUser"></bean>-->
<!-- 工厂中的静态方法创建Bean -->
<bean id="user" class="com.qf.factory.UserFactory" factory-method="getUserStatic"></bean>
</beans>
5.1.3简单工厂模式
Car
package com.qf.factorymode.simplefactory;
/**
* Car 接口
*/
public interface Car {
/**
* 提供 run 方法
*/
public void run();
}
package com.qf.factorymode.simplefactory;
/**
* Car 实现类
*/
public class BaoSJ implements Car {
@Override
public void run() {
System.out.println("保时捷在飞驰...");
}
}
package com.qf.factorymode.simplefactory;
/**
* Car 的实现类
*/
public class FaLL implements Car {
@Override
public void run() {
System.out.println("法拉利在飞驰...");
}
}
package com.qf.factorymode.simplefactory;
/**
* 简单工厂模式：代码集中，不符合 OCP 原则（ open - close ）：对代码的扩展是开放的，对代码的修改是关闭的
* 车工厂
*/
public class CarFactory {
//提供创建保时捷的方法
public static BaoSJ creatBaoSJ() {
try {
return (BaoSJ)Class.forName("com.qf.factorymode.simplefactory.BaoSJ").newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
//提供创建法拉利的方法
public static FaLL creatFaLL() {
try {
return (FaLL)Class.forName("com.qf.factorymode.simplefactory.FaLL").newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
测试
package com.qf.factorymode.simplefactory;
/**
* 测试类
*/
public class Test {
public static void main(String[] args) {
//创建对象，调用方法
//BaoSJ baoSJ = new BaoSJ();
BaoSJ baoSJ = CarFactory.creatBaoSJ();
baoSJ.run();
//创建对象，调用方法
//FaLL faLL = new FaLL();
FaLL faLL = CarFactory.creatFaLL();
faLL.run();
}
}
5.1.4抽象工厂模式
Car
package com.qf.factorymode.abstractfactory;
/**
* Car 接口
*/
public interface Car {
/**
* 提供 run 方法
*/
public void run();
}
package com.qf.factorymode.abstractfactory;
/**
* Car 实现类
*/
public class BaoSJ implements Car {
@Override
public void run() {
System.out.println("保时捷在飞驰...");
}
}
package com.qf.factorymode.abstractfactory;
/**
* Car 的实现类
*/
public class FaLL implements Car {
@Override
public void run() {
System.out.println("法拉利在飞驰...");
}
}
CarFactory
package com.qf.factorymode.abstractfactory;
/**
* 抽象工厂模式：符合开闭原则
* 车工厂
*/
public interface CarFactory {
/**
* 创建车的方法
* @return
*/
public Car createCar();
}
package com.qf.factorymode.abstractfactory;
/**
* 保时捷的车工厂
*/
public class BaoSJFactory implements CarFactory{
/**
* 创建保时捷车
* @return
*/
@Override
public Car createCar() {
try {
return (BaoSJ)Class.forName("com.qf.factorymode.abstractfactory.BaoSJ").newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
package com.qf.factorymode.abstractfactory;
/**
* 法拉利车工厂
*/
public class FaLLFactory implements CarFactory{
@Override
public Car createCar() {
try {
return (FaLL)Class.forName("com.qf.factorymode.abstractfactory.FaLL").newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
测试
package com.qf.factorymode.abstractfactory;
/**
* 测试类
*/
public class Test {
public static void main(String[] args) {
//创建对象，调用方法
BaoSJFactory baoSJFactory = new BaoSJFactory();
Car baoSJ = baoSJFactory.createCar();
baoSJ.run();
//创建对象，调用方法
FaLLFactory faLLFactory = new FaLLFactory();
Car faLL = faLLFactory.createCar();
faLL.run();
}
}
5.2 bean对象的作用范围
bean标签的scope属性：
作用：用于指定bean的作用范围
取值： 常用的就是单例的和多例的
singleton：单例的（默认值）
prototype：多例的
request：作用于web应用的请求范围
session：作用于web应用的会话范围
global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session
<!--
该id属性是标识单个 bean 定义的字符串。(不能重复)
该class属性定义 bean 的类型并使用完全限定的类名。
scope：常用的是单例（singleton）和多例（prototype）
-->
<bean id = "user" class = "com.qf.pojo.User" scope="singleton">
</bean>
测试
/**
* 测试单例和多例
*/
@Test
public void testUserScope() {
//需要加载配置文件
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
//根据bean标签中的id属性值，获取bean对象
User user1 = (User) applicationContext.getBean("user");
User user2 = (User) applicationContext.getBean("user");
System.out.println(user1 == user2);
}
5.2.1单例模式-懒汉式
package com.qf.singletonmode;
/**
* 单例模式：懒汉式（在第一次调用的时候实例化自己）
* 优势：第一次调用才会初始化，避免内存消耗
* 劣势：必须加锁才能保证单例，加锁会影响效率
*/
public class SingletonLazy {
//构造器私有化
private SingletonLazy() {}
//声明对象
private static SingletonLazy singletonLazy = null;
//实例化，线程安全
public static synchronized SingletonLazy getSingletonLazy() {
//判断
if(null == singletonLazy) {
singletonLazy = new SingletonLazy();
}
return singletonLazy;
}
}
5.2.2单例模式-饿汉式
package com.qf.singletonmode;
/**
* 饿汉式：比较常用，容易产生垃圾（ GC回收 ）
* 优势：没有加锁，效率会提高
* 劣势：类加载时就进行初始化，消耗内存
*/
public class SingletonHungry {
//私有化构造器
private SingletonHungry() {}
//实例化
private static SingletonHungry singletonHungry = new SingletonHungry();
//方法
public static SingletonHungry getSingletonHungry() {
return singletonHungry;
}
}
5.2.3单例模式-双重校验锁
package com.qf.singletonmode;
/**
* 双重校验锁
* 优势：安全，在多线程情况下保证较高的性能
*/
public class SingletonLock {
//构造器私有化
private SingletonLock() {}
//声明
private static SingletonLock singletonLock = null;
//实例化方法
public static SingletonLock getSingletonLock() {
//先检查当前实例是否为空，如果不存在再进行同步
if(null == singletonLock){
//同步
synchronized (SingletonLock.class) {
//再次检查当前实例是否为空
if(null == singletonLock){
//返回
singletonLock = new SingletonLock();
}
}
}
return singletonLock;
}
}
5.3 bean对象的生命周期
生命周期属性：
配置一个方法作为生命周期初始化方法. spring会在对象创建之后立即调用: init-method
配置一个方法作为生命周期的销毁方法. spring容器在关闭并销毁所有容器中的对象之前调用: destory-method
5.3.1applicationContext.xml中配置bean标签中的相关方法
<!--
该id属性是标识单个 bean 定义的字符串。(不能重复)
该class属性定义 bean 的类型并使用完全限定的类名。
scope：常用的是单例（singleton）和多例（prototype）
init-method：创建对象后执行的初始化方法
destroy-method：对象销毁后执行（如果是多例模式下不执行）
-->
<bean id = "user" class = "com.qf.pojo.User"
scope="singleton" init-method="initUser" destroy-method="destroyUser">
</bean>
5.3.2在实体类中添加对应的方法
package com.qf.pojo;
/**
* User实体类
*/
public class User {
private Integer id;
private String name;
private String password;
public User() {
System.out.println("无参构造");
}
/**
* 初始化方法，创建对象后执行
*/
public void initUser() {
System.out.println("User 初始化方法");
}
/**
* 销毁方法，销毁spring容器中对象后执行
*/
public void destroyUser() {
System.out.println("User 销毁方法");
}
}
5.3.3测试
/**
* 测试生命周期相关方法
*/
@Test
public void testLife() {
//创建ClassPathXmlApplicationContext对象
ClassPathXmlApplicationContext applicationContext
= new ClassPathXmlApplicationContext("applicationContext.xml");
//获取对象
User user = (User) applicationContext.getBean("user");
System.out.println(user);
//关闭
applicationContext.close();
}
六、Spring中的依赖注入
6.1 依赖注入
依赖注入：Dependency Injection
IOC的作用：降低程序间的耦合（依赖关系）
依赖关系的管理：以后都交给spring来维护，在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明
依赖关系的维护：就称之为依赖注入。
依赖注入：
能注入的数据：
基本类型和String
其他bean类型（在配置文件中或者注解配置过的bean）
复杂类型/集合类型
注入的方式：
第一种：使用set方法提供
第二种：使用构造函数提供（不常用）
第三种：使用注解提供
6.2 set方法注入
涉及的标签：property
出现的位置：bean标签的内部标签的属性：
name：用于指定注入时所调用的set方法名称
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象优势：
创建对象时没有明确的限制，可以直接使用默认构造函数
弊端：
如果有某个成员必须有值，则获取对象是有可能set方法没有执行。
6.2.1创建实体类
package com.qf.pojo;
import lombok.Data;
@Data
public class Car {
private Integer cid;
private String cname;
}
package com.qf.pojo;
import lombok.Data;
@Data
public class User {
private Integer id;
private String name;
private String password;
private Car car;
}
6.2.2配置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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 初始化一个Car对象 -->
<bean id="firstCar" class="com.qf.pojo.Car">
<property name="cid" value="20001"></property>
<property name="cname" value="保时捷"></property>
</bean>
<!--
该id属性是标识单个 bean 定义的字符串。(不能重复)
该class属性定义 bean 的类型并使用完全限定的类名。
-->
<bean id = "user" class = "com.qf.pojo.User">
<!-- set方法赋值
property表示当前对象的属性
name：属性名
value：给当前属性赋值
ref：用于注入其他Bean对象（在spring容器中已经创建了）
-->
<property name="id" value="1001"></property>
<property name="name" value="张三"></property>
<property name="password" value="123"></property>
<property name="car" ref="firstCar"></property>
</bean>
</beans>
6.2.3测试
package com.qf.test;
import com.qf.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* 测试类
*/
public class SpringTest {
@Test
public void testUser(){
//加载配置文件
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
//创建Bean
User user =(User)applicationContext.getBean("user");
//输出
System.out.println(user);
}
}
6.3 复杂类型的注入/集合类型的注入
1、用于给数组结构注入的标签：array
2、用于给List结构集合注入的标签：list set
3、用于个Map结构集合注入的标签：map properties
6.3.1创建实体类
package com.qf.vo;
import lombok.Data;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
@Data
public class CollectionVo {
private Integer [] arr;
private List list;
private Set set;
private Map map;
private Properties properties;
}
6.3.2配置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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 初始化一个Car对象 -->
<bean id="firstCar" class="com.qf.pojo.Car">
<property name="cid" value="20001"></property>
<property name="cname" value="保时捷"></property>
</bean>
<!--
该id属性是标识单个 bean 定义的字符串。(不能重复)
该class属性定义 bean 的类型并使用完全限定的类名。
-->
<bean id = "user" class = "com.qf.pojo.User">
<!-- set方法赋值
property表示当前对象的属性
name：属性名
value：给当前属性赋值
ref：用于注入其他Bean对象（在spring容器中已经创建了）
-->
<property name="id" value="1001"></property>
<property name="name" value="张三"></property>
<property name="password" value="123"></property>
<property name="car" ref="firstCar"></property>
</bean>
<!-- 复杂类型注入 -->
<bean id="collectionVo" class="com.qf.vo.CollectionVo">
<!-- 数组 -->
<property name="arr">
<array>
<value>123</value>
<value>456</value>
<value>789</value>
</array>
</property>
<!-- list -->
<property name="list">
<list>
<value>jack</value>
<value>jack</value>
<value>rose</value>
<ref bean="user"></ref>
</list>
</property>
<!-- set -->
<property name="set">
<set>
<value>jack</value>
<value>jack</value>
<value>rose</value>
<ref bean="user"></ref>
</set>
</property>
<!-- map -->
<property name="map">
<map>
<entry key="1001" value="张三"></entry>
<entry key-ref="user" value-ref="firstCar"></entry>
</map>
</property>
<!-- properties -->
<property name="properties">
<props>
<prop key="username">root</prop>
<prop key="password">root</prop>
<prop key="url">jdbc:mysql:///db_name</prop>
<prop key="driverClassName">com.mysql.cj.jdbc.Driver</prop>
</props>
</property>
</bean>
</beans>
6.3.3测试
@Test
public void testCollectionVo(){
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
CollectionVo collectionVo = (CollectionVo)applicationContext.getBean("collectionVo");
System.out.println(collectionVo);
}
6.4 构造函数注入
使用的标签:constructor-arg
标签出现的位置：bean标签的内部标签中的属性：
name：用于指定给构造函数中指定名称的参数赋值
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始优势：
在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
弊端：
改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。
6.4.1创建实体类
Car
package com.qf.pojo;
import lombok.Data;
@Data
public class Car {
private Integer cid;
private String cname;
public Car(Integer cid, String cname) {
this.cid = cid;
this.cname = cname;
}
}
User
package com.qf.pojo;
import lombok.Data;
@Data
public class User {
private Integer id;
private String name;
private String password;
private Car car;
public User(Integer id, String name, String password, Car car) {
this.id = id;
this.name = name;
this.password = password;
this.car = car;
System.out.println("有参构造器1");
}
public User(String name,Integer id, String password, Car car) {
this.id = id;
this.name = name;
this.password = password;
this.car = car;
System.out.println("有参构造器2");
}
}
6.4.2配置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"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 初始化一个Car对象，如果类中只提供了有参构造器，则不能再使用无参构造器实例化对象 -->
<bean id="car" class="com.qf.pojo.Car">
<!-- 构造器注入 -->
<constructor-arg name="cid" value="20001"></constructor-arg>
<constructor-arg name="cname" value="保时捷"></constructor-arg>
</bean>
<!-- 初始化第一个User对象 -->
<bean id="user1" class="com.qf.pojo.User">
<!-- 构造器注入 -->
<constructor-arg name="id" type="java.lang.Integer" value="1001" index="0"></constructor-arg>
<constructor-arg name="name" value="张三" index="1"></constructor-arg>
<constructor-arg name="password" value="123" index="2"></constructor-arg>
<constructor-arg name="car" ref="car" index="3"></constructor-arg>
</bean>
<!-- 初始化第二个User对象 -->
<bean id="user2" class="com.qf.pojo.User">
<!-- 构造器注入 -->
<constructor-arg name="name" value="李四" index="0"></constructor-arg>
<constructor-arg name="id" type="java.lang.Integer" value="1002" index="1"></constructor-arg>
<constructor-arg name="password" value="456" index="2"></constructor-arg>
<constructor-arg name="car" ref="car" index="3"></constructor-arg>
</bean>
</beans>
6.4.3测试
package com.qf.test;
import com.qf.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
@Test
public void testUser(){
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
User user1 = (User)applicationContext.getBean("user1");
System.out.println(user1);
User user2 = (User)applicationContext.getBean("user2");
System.out.println(user2);
}
}
6.5 注解方法注入（需要在applicationContext.xml中的添加context约束）
用于创建对象的
他们的作用就和在XML配置文件中编写一个标签实现的功能是一样的
@Component:用于把当前类对象存入spring容器中
value属性：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。
@Controller：一般用在表现层
@Service：一般用在业务层
@Repository：一般用在持久层
以上三个注解的作用和属性与Component相同，是spring框架为我们提供明确的三层使用的注解
用于注入数据的
他们的作用就和在xml配置文件中的bean标签中写一个标签的作用是一样的
@Autowired:自动按照类型注入
@Qualifier:在按照类中注入的基础之上再按照名称注入，value属性：用于指定注入bean的id
@Resource：直接按照bean的id注入。它可以独立使用，name属性：用于指定bean的id注意：以上三个注入都只能注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现，另外，集合类型的注入只能通过XML来实现。因为Resource注解是J2EE的，而不是Spring本身的，所以在使用时需要在pom.xml中导入依赖：
<dependency> <groupId>javax.annotation</groupId> <artifactId>javax.annotation-api</artifactId> <version>1.3.2</version> </dependency>
@Value：用于注入基本类型和String类型的数据
用于改变作用范围的
作用和在bean标签中使用scope属性实现的功能是一样的
@Scope：用于指定bean的作用范围
value：指定范围的取值。常用取值：singleton prototype
和生命周期相关
作用和在bean标签中使用init-method和destroy-methode的作用是一样的
@PreDestroy：用于指定销毁方法
@PostConstruct：用于指定初始化方法
在当前applicationContext.xml配置文件中引入其他配置文件
<import resource="bean.xml"></import>
6.5.1创建实体类
Car
package com.qf.pojo;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
@Data
public class Car {
@Value("20001")
private Integer cid;
@Value("法拉利")
private String cname;
// @Value("保时捷")
// public void setCname(String cname) {
// this.cname = cname;
// }
}
User
package com.qf.pojo;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
@Component
@Data
//@Scope("prototype")//默认：singleton 单例，prototype表示多例
public class User {
@Value("1001")
private Integer id;
@Value("张三")
private String name;
@Value("123")
private String password;
//@Qualifier 和 @Autowired 一起使用，指定类型的对象注入
@Autowired
@Qualifier("car")
//@Resource相当于上面两个注解
//@Resource(name = "otherCar")
private Car car;
@PostConstruct//相当与 bean中的 init-method 属性
public void init(){
System.out.println("初始化方法");
}
@PreDestroy//相当与 bean中的 destroy-method 属性
public void destroy(){
System.out.println("销毁方法");
}
}
6.5.2创建配置类
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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- bean definitions here -->
<!-- 扫描对应包下的注解 -->
<context:component-scan base-package="com.qf"></context:component-scan>
<bean id="otherCar" class="com.qf.pojo.Car">
<property name="cname" value="帕萨特"></property>
</bean>
</beans>
bean.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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- bean definitions here -->
<!-- 导入其他配置文件 -->
<import resource="applicationContext.xml"></import>
</beans>
6.5.3测试
package com.qf.test;
import com.qf.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
//测试注解方式
@Test
public void testUser(){
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
User user = (User)applicationContext.getBean("user");
System.out.println(user);
}
//测试bean的范围
@Test
public void testScope(){
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
User user1 = (User)applicationContext.getBean("user");
User user2 = (User)applicationContext.getBean("user");
System.out.println(user1 == user2);
}
//测试使用其他配置文件
@Test
public void testLife(){
ClassPathXmlApplicationContext applicationContext =
new ClassPathXmlApplicationContext("bean.xml");
User user = (User)applicationContext.getBean("user");
System.out.println(user);
applicationContext.close();
}
}
