2 - 配置/管理 Bean-IOC
1. 基于 XML 配置 Bean
在上一篇里已经模拟了通过 id 来配置获取 bean
依然是使用 Monster 类
1.1 通过类型获取
1）xml 配置
2）测试
@Test
public void getMonsterByType() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Monster monster = ioc.getBean(Monster.class);
System.out.println("monster=" + monster);
Monster monster2 = ioc.getBean(Monster.class);
System.out.println("monster == monster2 的值= " + (monster == monster2));
//是同一个对象
}3）细节说明
- 按类型来获取 bean, 要求 ioc 容器中的同一个类的 bean 只能有一个
- 这种方式的应用场景：比如 XxxAction/Servlet/Controller, 或 XxxService在一个线程
中只需要一个对象实例(单例)的情况 - 在容器配置文件(比如 beans.xml)中给属性赋值, 底层是通过setter 方法完成的, 这也是为什么我们需要提供 setter 方法的原因
1.2 通过构造器配置
1）xml 配置
index 表示构造器的第几个参数，从 0 开始计数
还可以通过 name/type 来指定参数方式
2）测试
@Test
public void getMonsterByConstructor() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Object monster02 = ioc.getBean("monster02");
Object monster03 = ioc.getBean("monster03");
Object monster04 = ioc.getBean("monster03");
System.out.println("monster02= " + monster02);
System.out.println("monster03= " + monster03);
System.out.println("monster04= " + monster04);
}3）细节说明
- 通过 index 属性来区分是第几个参数
- 通过 type 属性来区分是什么类型(按照顺序)
1.3 通过 p 名称空间配置
1）xml 配置
增加命名空间配置
xmlns:p="http://www.springframework.org/schema/p"通过 p 名称空间来配置 bean 对象，其实将光标放在 p 的地方，alt+enter 就可以添加 xmlns
2）测试
@Test
public void getMonsterByP() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Monster monster04 = ioc.getBean("monster06", Monster.class);
System.out.println("monster06=" + monster06);
}1.4 引用/注入其它 bean 对象
在 spring 的 ioc 容器, 可以通过 ref 来实现 bean 对象的相互引用
1）创建对象
...\spring\dao\MemberDAOImpl.java
public class MemberDAOImpl {
public MemberDAOImpl() {
System.out.println("MemberDAOImpl 构造器...");
}
public void add() {
System.out.println("MemberDAOImpl add()方法");
}
}...\spring\service\MemberServiceImpl.java
public class MemberServiceImpl {
private MemberDAOImpl memberDAO;
public MemberServiceImpl() {
System.out.println("MemberServiceImpl 构造器~");
}
public void add() {
System.out.println("MemberServiceImpl add()...");
memberDAO.add();
}
public void setMemberDAO(MemberDAOImpl memberDAO) {
this.memberDAO = memberDAO;
}
public MemberDAOImpl getMemberDAO() {
return memberDAO;
}
}2）xml 配置
ref 表示 memberDAO 这个属性将引用/指向 id = memberDAOImpl 对象
就体现了 Spring 容器的依赖注入
注：在Spring容器中是作为一个整体运行的，创建引用是不分前后顺序
3）测试
@Test
public void setBeanByRef() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
MemberServiceImpl memberServiceImpl = ioc.getBean("memberServiceImpl",
MemberServiceImpl.class);
memberServiceImpl.add();
}4）结构
说明确实是引用关系
1.5 引用/注入内部 bean 对象
在 spring 的 ioc 容器, 可以直接配置内部 bean 对象
1）修改 xml 配置
自己配置一个内部 bean
2）测试
@Test
public void setBeanByPro() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
MemberServiceImpl memberServiceImpl02 = ioc.getBean("memberServiceImpl02",
MemberServiceImpl.class);
memberServiceImpl02.add();
}1.6 引用/注入集合/数组类型
如何给 bean 对象的集合/数组类型属性赋值
1）创建对象
...\spring\beans\Master.java
public class Master {
private String name;
private List monsterList;
private Map monsterMap;
private Set monsterSet;
private String[] monsterName;
//这个 Properties 是 Hashtable 的子类 , 是 key-value 的形式
//这里 Properties key 和 value 都是 String
private Properties pros;
public Master() {}
public Master(String name) {this.name = name;}
public Set getMonsterSet() {return monsterSet;}
public void setMonsterSet(Set monsterSet) {
this.monsterSet = monsterSet;
}
public String[] getMonsterName() {return monsterName;}
public void setMonsterName(String[] monsterName) {
this.monsterName = monsterName;
}
public String getName() {return name;}
public void setName(String name) {
this.name = name;
}
public List getMonsterList() {return monsterList;}
public void setMonsterList(List monsterList) {
this.monsterList = monsterList;
}
public Map getMonsterMap() {return monsterMap;}
public void setMonsterMap(Map monsterMap) {
this.monsterMap = monsterMap;
}
public Properties getPros() {return pros;}
public void setPros(Properties pros) {
this.pros = pros;
}
} 2）xml 配置
给集合属性注入值
Java 工程师
前端工程师
大数据工程师
银角大王
金角大王
3）测试
@Test
public void setCollectionByPro() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Master master01 = ioc.getBean("master01", Master.class);
//获取 list 集合
System.out.println("======list=======");
List monster_list = master01.getMonsterList();
for (Monster monster : monster_list) {
System.out.println(monster);
}
//获取 map 集合
System.out.println("======map=======");
Map monster_map = master01.getMonsterMap();
Set> entrySet = monster_map.entrySet();
for (Map.Entry entry : entrySet) {
System.out.println(entry);
}
//获取 properties 集合
System.out.println("======properties=======");
Properties pros = master01.getPros();
String property1 = pros.getProperty("k1");
String property2 = pros.getProperty("k2");
String property3 = pros.getProperty("k3");
System.out.println(property1 + "\t" + property2 + "\t" + property3);
//获取数组
System.out.println("======数组=======");
String[] monsterName = master01.getMonsterName();
for (String s : monsterName) {
System.out.println("妖怪名= " + s);
}
//获取 set
System.out.println("======set=======");
Set monsterSet = master01.getMonsterSet();
for (Monster monster : monsterSet) {
System.out.println(monster);
}
} 4）细节
Properties 集合的特点：
- Properties 是 Hashtable 的子类 , 是 key-value 的形式
- key 是 string 而 value 也是 string
1.7 通过 util 名称空间创建 list
spring 的 ioc 容器, 可以通过 util 名称空间创建 list 集合
1）创建对象
public class BookStore {//书店
private List bookList;
public BookStore() {}
public List getBookList() {
return bookList;
}
public void setBookList(List bookList) {
this.bookList = bookList;
}
} 2）xml 配置
增加配置
xmlns:util="http://www.springframework.org/schema/util"对象配置：
三国演义
西游记
红楼梦
水浒传
3）测试
@Test
public void getListByUtil() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
BookStore bookStore = ioc.getBean("bookStore", BookStore.class);
List bookList = bookStore.getBookList();
for (String s : bookList) {
System.out.println(s);
}
} 1.8 级联属性赋值
可以直接给对象属性的属性赋值， 即级联属性赋值
1）创建对象
...\spring\beans\Dept.java
public class Dept {
private String name;
public Dept() {}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}...\spring\beans\Emp.java
public class Emp {
private String name;
private Dept dept;
public Emp() {}
public String getName() {return name;}
public void setName(String name) {
this.name = name;
}
public Dept getDept() {return dept;}
public void setDept(Dept dept) {
this.dept = dept;
}
}2）xml 配置
3）测试
@Test
public void setProByRelation() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Emp emp = ioc.getBean("emp", Emp.class);
System.out.println(emp.getDept().getName());
}1.9 通过静态工厂获取对象
1）创建对象
...\spring\factory\MyStaticFactory.java
public class MyStaticFactory {
private static Map monsterMap;
// 使用 static 代码块进行初始化
static {
monsterMap = new HashMap();
monsterMap.put("monster01", new Monster(100, "黄袍怪", "一阳指"));
monsterMap.put("monster02", new Monster(200, "九头金雕", "如来神掌"));
}
public static Monster getMonster(String key) {
return monsterMap.get(key);
}
} 2）xml 配置
1. 通过静态工厂获取/配置bean
2. class 是静态工厂类的全路径
3. factory-method 表示是指定静态工厂类的哪个方法返回对象
4. constructor-arg value="monster02" value是指定要返回静态工厂的哪个对象
3）测试
@Test
public void getBeanByStaticFactory() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Monster my_monster = ioc.getBean("my_monster01", Monster.class);
System.out.println(my_monster);
}1.10 通过实例工厂获取对象
与静态工厂不同的地方在于，需要先有一个实例工厂才能获得对象
1）创建对象
...\spring\factory\MyInstanceFactory.java
public class MyInstanceFactory {
private Map monster_map;
//非静态代码块
{
monster_map = new HashMap();
monster_map.put("monster_01", new Monster(100, "猴子精", "吃人"));
monster_map.put("monster_02", new Monster(200, "九头金雕", "如来神掌"));
}
public Monster getMonster(String key) {
return monster_map.get(key);
}
} 2）xml 配置
3）测试
@Test
public void getBeanByInstanceFactory() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Monster my_monster = ioc.getBean("my_monster2", Monster.class);
System.out.println(my_monster);
}1.11 通过 FactoryBean 获取对象（重点）
1）创建对象
...\spring\factory\MyFactoryBean.java
public class MyFactoryBean implements FactoryBean {
private String keyVal;
private Map monster_map;
{ // 代码块完成初始化任务
monster_map = new HashMap();
monster_map.put("monster_01", new Monster(100, "黄袍怪", "一阳指"));
monster_map.put("monster_02", new Monster(200, "九头金雕", "如来神掌"));
}
public void setKeyVal(String keyVal) {
this.keyVal = keyVal;
}
@Override
public Monster getObject() throws Exception {
// TODO Auto-generated method stub
return this.monster_map.get(keyVal);
}
@Override
public Class getObjectType() {
// TODO Auto-generated method stub
return Monster.class;
}
@Override
public boolean isSingleton() {
// TODO Auto-generated method stub
// 指定是否是返回单例
return true;
}
} 2）xml 配置
3）测试
@Test
public void getBeanByFactoryBean() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Monster monster = ioc.getBean("myFactoryBean", Monster.class);
System.out.println(monster);
}1.12 bean 配置信息重用(继承)
在 spring 的 ioc 容器, 提供了一种继承的方式来实现 bean 配置信息的重用
1）xml 配置
如果要创建一个 配置信息是一样的对象的话，可以进行继承
当我们把某个 bean 设置为 abstract="true" 这个 bean只能被继承，而不能实例化了，类似与java 的抽象类
2）测试
@Test
public void getBeanByExtends() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Monster monster1 = ioc.getBean("monster11", Monster.class);
System.out.println(monster1);
Monster monster2 = (Monster) ioc.getBean("monster13", Monster.class);
System.out.println(monster2);
}1.13 bean 创建顺序
在 spring 的 ioc 容器, 默认是按照配置的顺序创建 bean 对象
会先创建 student01 这个 bean 对象，然后创建 department01 这个 bean 对象
如果这样配置，增加了 depends-on="xxx"
会先创建 department01 对象，再创建 student01 对象
1.14 bean 对象的单例和多例
在默认是按照单例创建的，即配置一个 bean 对象后，ioc 容器只会创建一个 bean 实例
想要以多个实例形式创建某个 bean 对象的则可以通过配置scope="prototype" 来指定
1）创建对象
...\spring\beans\Car.java
public class Car {
public Car() {
System.out.println("car 构造器");
}
}2）xml 配置
3）测试
@Test
public void getBeanByPrototype() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
for (int i = 0; i < 3; i++) {
Car car = ioc.getBean("car", Car.class);
System.out.println(car);
}
}4）细节
- 默认是单例 singleton, 在启动容器时, 默认就会创建 , 并放入到 singletonObjects 集合
设置为多实例机制后,该 bean 是在 getBean()时才创建 - 如 果 是 单 例 singleton, 同 时 希 望 在 getBean 时 才创建 , 可指定懒加载
lazy-init="true" (注意默认是 false) - lazy-init 就使用默认值 false , 在开发看来, 用空间换时间是值得的, 除非有特殊的要求
- scope="prototype" 这时你的 lazy-init 属性的值不管是 ture, 还是 false 都是在 getBean 时，才创建对象
1.15 bean 的生命周期
bean 对象创建是由 JVM 完成的，然后执行如下方法
- 执行构造器
- 执行 set 相关方法
- 调用 bean 的初始化的方法（需要配置）
- 使用 bean
- 当容器关闭时候，调用 bean 的销毁方法（需要配置）
1）创建对象
...\spring\beans\House.java
public class House {
private String name;
public House() {
System.out.println("House() 构造器");
}
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("House setName()...");
this.name = name;
}
public void init() {
System.out.println("House init()..");
}
public void destory() {
System.out.println("House destory()..");
}
}2）xml 配置
配置 bean 的初始化方法和销毁方法
3）测试
@Test
public void beanLife() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
House house = ioc.getBean("house", House.class);
System.out.println(house);
//关闭容器 ConfigurableApplicationContext 是有 close 方法的
((ConfigurableApplicationContext) ioc).close();
}4）使用细节
- 初始化 init 方法和 destory 方法, 是程序员来指定，名字也不一定是叫这个名字，在配置文件里进行指定是调用那个方法作为初始化/销毁方法
- 销毁方法就是当关闭容器时，才会被调用
1.16 配置 bean 的后置处理器（重点）
- 在 spring 的 ioc 容器,可以配置 bean 的后置处理器
- 该处理器/对象会在 bean 初始化方法调用前和初始化方法调用后被调用
- 在后置处理器中编写自己的代码
1）创建后置处理器
...\spring\beans\MyBeanPostProcessor.java
要实现 BeanPostProcessor 接口的两个方法作为一个前一个后
public class MyBeanPostProcessor implements BeanPostProcessor {
/**
* 在 bean 初始化之前完成某些任务
* @param bean: 就是 ioc 容器返回的 bean 对象,
* 如果被替换会修改，返回的 bean 对象也会被修改
* @param beanName: 就是 ioc 容器配置的 bean 的名称
* @return Object: 就是返回的 bean 对象
*/
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
// TODO Auto-generated method stub
System.out.println("postProcessBeforeInitialization被 调 用"
+ beanName + "bean= " + bean.getClass());
return bean;
}
/**
* 在 bean 初始化之后完成某些任务
* @param bean: 就是 ioc 容器返回的 bean 对象, 如果被替换会修改，
* 返回的 bean 对象也会被修改
* @param beanName: 就是 ioc 容器配置的 bean 的名称
* @return Object: 就是返回的 bean 对象
*/
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("postProcessAfterInitialization 被调用 "
+ beanName + " bean= "+ bean.getClass());
return bean;
}
}
2）xml 配置
bean 后置处理器的配置，配置后这个后置处理器作用在该容器创建的 bean 对象中
3）测试
@Test
public void testBeanPostProcessor() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans02.xml");
House house = ioc.getBean("house", House.class);
System.out.println(house);
//关闭容器
((ConfigurableApplicationContext) ioc).close();
}就已经可以触发后置处理器了！！！
4）说明
1. 怎么执行到这个方法?
使用 AOP(反射+动态代理+IO+容器+注解)
2、有什么用？
可以对 IOC 容器中所有的对象进行统一处理 ,比如 日志处理/权限的校验/安全的验证/事务管理
3、针对容器的所有对象吗?
是的 => 这也就是AOP切面编程特点
1.17 通过属性文件给 bean 注入值
1）创建 my.properties
在 src 目录下创建 注以是 Unicode 编码
name=\u9EC4\u888D\u602A
id=10
skill=\u72EE\u5B50\u543C2）xml 配置
1. 通过属性文件给 bean 注入值,
2. 需要导入: xmlns:context 名字空间,并指定属性文件路径 location="xxxx"
3）测试
@Test
public void setProByProFile() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Monster monster100 = ioc.getBean("monster100", Monster.class);
System.out.println(monster100);
}1.18 基于 XML 的 bean 的自动装配
1）创建对象
...\spring\dao\OrderDao.java
public class OrderDao {
public void saveOrder() {
System.out.println("保存 一个订单...");
}
}...\spring\service\OrderService.java
public class OrderService {
private OrderDao orderDao;
public OrderDao getOrderDao() {
return orderDao;
}
public void setOrderDao(OrderDao orderDao) {
this.orderDao = orderDao;
}
}...\spring\action\OrderAction.java
public class OrderAction {
private OrderService orderService;
public OrderService getOrderService() {
return orderService;
}
public void setOrderService(OrderService orderService) {
this.orderService = orderService;
}
}2）xml 配置
autowire="byType" 表示根据类型进行自动组装
比如OrderService 对象有 private OrderDao orderDao，就会在容器中去找有没有 OrderDao类型对象；如果有，就会自动的装配 --> 这个容器中，不能有两个的OrderDao类型对象
autowire = "byName" 表示通过名字完成自动装配
OrderService 属性 private OrderDao orderDao，根据这个属性的setXxx()方法的 xxx 来找对象id，public void setOrderDao() 就会找id=orderDao对象来进行自动装配，如果没有就装配失败
3）测试
@Test
public void setProByAutowire() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
OrderAction orderAction = ioc.getBean("orderAction", OrderAction.class);
orderAction.getOrderService().getOrderDao().saveOrder();
}4）说明
这个知识点作为了解即可，后面主要还是使用基于注解的方式
1.19 spring el 表达式
支持运行时查询并可以操作对象
1）创建对象
...\spring\beans\SpELBean.java
public class SpELBean {
private String name;
private Monster monster;
private String monsterName;
private String crySound;
private String bookName;
private Double result;
public SpELBean() {}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public Monster getMonster() {return monster;}
public void setMonster(Monster monster) {this.monster = monster;}
public String getMonsterName() {return monsterName;}
public void setMonsterName(String monsterName) {this.monsterName = monsterName;}
public String getCrySound() {return crySound;}
public void setCrySound(String crySound) {this.crySound = crySound;}
public String getBookName() {return bookName;}
public void setBookName(String bookName) {this.bookName = bookName;}
public Double getResult() {return result;}
public void setResult(Double result) {this.result = result;}
public String cry(String sound) {return "发出 " + sound + "叫声...";}
public static String read(String bookName) {return "正在看 " + bookName;}
}2）xml 配置
3）测试
@Test
public void setProBySpel() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
SpELBean spELBean = ioc.getBean("spELBean", SpELBean.class);
System.out.println(spELBean.getName());
System.out.println(spELBean.getMonster());
System.out.println(spELBean.getMonsterName());
System.out.println(spELBean.getCrySound());
System.out.println(spELBean.getBookName());
System.out.println(spELBean.getResult());
}4）说明
不是重点，如果看到有人这样使用，能看懂即可
2. 基于注解配置 bean
基于注解的方式配置 bean, 主要是项目开发中的组件，比如 Controller、Service、和 Dao
组件注解的形式有：
- @Component 表示当前注解标识的是一个组件
- @Controller 表示当前注解标识的是一个控制器，通常用于 Servlet
- @Service 表示当前注解标识的是一个处理业务逻辑的类，通常用于 Service 类
- @Repository 表示当前注解标识的是一个持久化层的类，通常用于 Dao 类
2.1 快速入门
1）引入包 spring-aop-5.3.8.jar
2）创建对象
@Repository
public class UserDao {
}
@Service
public class UserService {
}
@Controller
public class UserAction {
}
@Component
public class MyComponent {
}3）xml 配置
配置自动扫描的包，注意需要加入 context 名称空间
- component-scan 要对指定包下的类进行扫描, 并创建对象到容器
- base-package 指定要扫描的包
- 当spring容器创建/初始化时，就会扫描com.hspedu.spring.component包下的所有的 有注解 @Controller / @Service / @Respository / @Component类 将其实例化，生成对象，放入到ioc容器
- resource-pattern="User*.class" 表示只扫描com.hspedu.spring.component 和它的子包下的User打头的类（使用较少，其实只要不加注解就能解决）
4）测试
@Test
public void getBeanByAnnotation() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
UserAction userAction = ioc.getBean(UserAction.class);
System.out.println(userAction);
UserDao userDao = ioc.getBean(UserDao.class);
System.out.println(userDao);
MyComponent myComponent = ioc.getBean(MyComponent.class);
System.out.println(myComponent);
UserService userService = ioc.getBean(UserService.class);
System.out.println(userService);
}调试查看 ioc 容器
5）注意
Spring 的 IOC 容器不能检测一个使用了@Controller 注解的类到底是不是一个真正的控制器
注解的名称是用于程序员自己识别当前标识的是什么组件。
其它的@Service @Repository 也是一样的道理 （也就是说 spring 的 IOC 容器只要检查到注解就会生成对象，但是这个注解的含义 spring 不会识别，注解是给程序员编程方便看的）
6）排除某种类型下的某种类型的注解
- type="annotation" 按照注解类型进行过滤
- expression :就是注解的全类名，这里就是 @Service 注解的全类名
- 上面表示过滤掉 com.hspedu.spring.component 包下，加入了@Service 注解的类
7）指定自动扫描哪些注解类
目的：只扫描 Service Controller
8）注解类名
默认情况：标记注解后，类名首字母小写作为 id 的值
也可以使用注解的 value 属性指定 id 值，并且 value 可以省略
@Controller(value="userAction01")
@Controller("userAction01")9）拓展
链接：彻底弄懂@Controller 、@Service、@Component