1.IOC容器创建的2种方式
//首先在applicationContext.xml配置文件中写
<bean id="user" name="1ds@@user" class="c_ioc_bean.user"/>
//创建方式一：
//Spring把所有的配置文件都当做资源
ClassPathResource resource = new ClassPathResource("applicationContext.xml");
BeanFactory beanFactory = new XmlBeanFactory(resource);
beanFactory.getBean("user");
//创建方式二：
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
ac.getBean("user");//这里AppicationContext是BeanFactory下的接口2.Bean配置的详解
//User类
package c_ioc_bean;
public class user {
private String id;
private String name;
public user() {
System.out.println("user.user()");
}
public void init(){
System.out.println("user.init()");
}
public void destroy(){
System.out.println("user.enclosing_method()");
}
}
<!--
bean的高级配置
1.单例/多例
通过scope='singleton',scope='prototype'分别来指定
默认也是单例的
如果是单例，则在ioc容器创建时，就会创建各个单例对象，以后从容器中取都是取这个单例对象
如果是多例，则在ioc容器创建后，每次从容器取都会创建一个对象
2.延迟初始化（是针对单例对象来说的）
lazy-init='default'或lazy-init='false' 表示不启用
lazy-init='true'表示启用
意思是ioc容器创建后，不会立即创建单例对象，而是当第一次从容器中获取才会创建
3.初始化/销毁 方法
当bean对象创建后，会调用init-method中指定的初始化方法
当销毁容器对象后，会调用destroy-method中指定的bean的销毁方法（此时不能用ApplicationContext接口）
Bean声明周期：
scope="singleton"
1. 如果bean作用域是单例, 看是否延迟初始化
1.1 如果没有配置延迟初始化(默认)，或lazy-init=false
创建容器对象的时候，创建applicationContext.xml配置的所有单例对象
1.2 如果配置lzy-init=true
在创建容器对象后，在第一次从容器中获取实例时候，才创建对象
2. 创建完bean实例，执行init-metho配置的初始化方法
3. 当销毁容器对象的时候，即调用ClassPathXmlApplicationContext对象的destroy方法的时候, 执行对象的destroy-method配置的对应方法;
表示对象销毁
scope="prototype"
注意： 如果对象是多例，根lazy-init配置没有关系，影响不到！
1. 先创建IOC容器对象
2. 每次从容器获取bean，才创建对象
3. 创建完对象后，执行初始化方法 (每次创建对象后执行)
4. 对象创建完毕
5. 容器销毁，执行destroy方法
-->
<bean id="user" name="1ds@@user" class="c_ioc_bean.user" scope="singleton" lazy-init="true" init-method="init" destroy-method="destroy"></bean>3.spring IOC容器详解
3.1 IOC容器创建对象
3.1.1通过无参构造方法创建对象
<!-- 1.无参构造方法创建对象 -->
<bean id="user" class="d_create_object.user"></bean>3.1.2通过带参数的构造方法创建对象
<!-- 2.调用有参构造方法创建对象 -->
<bean id="str" class="java.lang.String"><!-- new String("jack") -->
<constructor-arg value="jack"></constructor-arg>
</bean>
<!--
index 形数下标
name 形参的名字
注意：index,name二选一即可，也可以一个都不选，但是参数要按顺序写，否则报错
type 参数类型
值有如下两种赋法
value 直接给对象属性赋值
ref 引用另外一个对象，这个被引用的对象要写bean配置（即只能引用容器里的值）
-->
<bean id="user2" class="d_create_object.user">
<constructor-arg name="id" type="int" value="12"></constructor-arg>
<constructor-arg index="1" type="String" ref="str"></constructor-arg>
</bean>3.1.3通过工厂类创建对象
public class Factory {//工厂类
public static String getStaticInstance(){//静态方法
return new String("factory_static");
}
public String getInstance(){ //非静态方法
return new String("factory_no_static");
}
}
3.1.3.1通过工厂类的静态方法创建对象
<!-- a.工厂类静态方法 创建对象 -->
<bean id="user3" class="d_create_object.Factory" factory-method="getStaticInstance"></bean>3.1.3.2通过工厂类的非静态方法创建对象
<!-- b.工厂类非静态方法创建对象 -->
<bean id="factory" class="d_create_object.Factory"></bean>
<bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>3.2处理对象依赖关系
何为处理对的依赖关系？何为依赖注入(DI)?
依赖注入就是用来处理对象依赖关系，通俗点就是给对象的属性赋值
3.2.1通过set方式
//javaBean
package e_di;
import java.util.List;
import java.util.Map;
import java.util.Properties;
public class user {
private int id;
private String name;
private List<Object> list;
private Map<Object, Object>map;
private Properties prop;
public user() {
System.out.println("user.user()");
}
public user(int id, String name) {
super();
this.id = id;
this.name = name;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setList(List<Object> list) {
this.list = list;
}
public void setMap(Map<Object, Object> map) {
this.map = map;
}
public void setProp(Properties prop) {
this.prop = prop;
}
public void init(){
System.out.println("user.init()");
}
public void destroy(){
System.out.println("user.enclosing_method()");
}
@Override
public String toString() {
return "user [id=" + id + ", name=" + name + ", list=" + list + ", map=" + map + ", prop=" + prop + "]";
}
}
<!--
依赖注入：处理对象的依赖关系，就是给对象的属性赋值
-->
<!--
构造方法的形式
-->
<bean id="user1" class="e_di.user">
<constructor-arg value="1"></constructor-arg>
<constructor-arg value="jack"></constructor-arg>
</bean>
<!--
set方式
property name set方法后面的部分函数名
value 基本类型的值
ref 引用容器中对象的值
-->
<bean id="user2" class="e_di.user">
<property name="id" value="2"></property>
<property name="name" value="tom"></property>
</bean>
<!--
set方式给List,map.Properties赋值
-->
<bean id="user3" class="e_di.user">
<property name="list">
<list>
<value>中国</value>
<value>美国</value>
<value>日本</value>
</list>
</property>
</bean>
<bean id="user4" class="e_di.user">
<property name="map">
<map>
<entry key="ch" value="中国"></entry>
<entry key="en" value="美国"></entry>
</map>
</property>
</bean>
<bean id="user" class="e_di.user">
<property name="prop">
<props>
<prop key="ch">中国</prop>
<prop key="en">美国</prop>
</props>
</property>
</bean>
</beans>3.2.2内部bean的方式
//内部Bean就是set方式简化版。但是因为是通过bean的内部嵌套定义的，所以缺点是只能一次性使用。 当还需要在其他处使用内部的这些bean时，还需要重新定义
<!--
set方式
<bean id="userDao" class="f_in.UserDaoImp"></bean>
<bean id="userService" class="f_in.UserServiceImp">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userAction" class="f_in.UserAction">
<property name="userService" ref="userService"></property>
</bean>
-->
<!-- 内部bean方式 -->
<bean id="userAction" class="f_in.UserAction">
<property name="userService">
<bean class="f_in.UserServiceImp">
<property name="userDao">
<bean class="f_in.UserDaoImp"></bean>
</property>
</bean>
</property>
</bean>3.2.3p名称空间注入
//P名称空间
1.首先要在xml文件顶部的<beans></beans>中引入p名称空间 xmlns:p="http://www.springframework.org/schema/p"
然后
2.再按如下方式写配置
<!--
P名字空间
1.首先引入p名字空间 xmlns:p="http://www.springframework.org/schema/p"
2.然后写配置,就是在每个bean中，在需要的赋值的属性前加个p:,例如需要给userAction的userService属性赋值，然后这个值是引入容器里的对象userService
-->
<bean id="userDao" class="f_in.UserDaoImp"></bean>
<bean id="userService" class="f_in.UserServiceImp" p:userDao="userDao"></bean>
<bean id="userAction" class="f_in.UserAction" p:userService="userService"></bean>
</beans>3.2.4自动装载
<!--
自动装载
autowire="default"不自动装载
1. autowire="byName"，会根据setXXX(T obj)方法中对象XX的名字自动去容器中找bean的ID和它相同的对象
2. autowire="byType",会根据setXXX(T obj)方法中对象XX的类型自动去容器中找bean的ID和它相同的对象
3. 全局配置：在根标签中加default-autowire="XXXX"
自动装载的缺点：
如果是byType，则配置文件中相同类型的bean只能有一个
因为不是手动指定，所以不利于后期维护，所以不推荐使用
-->
<!-- 方式一： autowire="byName"-->
<bean id="userDao" class="h_auto.UserDaoImp" autowire="byName"></bean>
<!--方式二:autowire="byType" -->
<bean id="userService" class="h_auto.UserServiceImp" autowire="byType"></bean>
<!--方式三： 方式3： 全局自动装配
default-autowire="byType"
或者，
default-autowire="byName"
定义到根节点，表示所有的bean都使用自动装配：根据名称或类型3.2.5注解
总结：可以简化配置！
@Component 把对象加入ioc容器，对象引用名称是类名，第一个字母小写
@Component(“name”) 把指定名称的对象，加入ioc容器
@Repository 同@Component , 主要用于标识加入容器的对象是一个持久层的组件(类)
@Service 同@Component , 主要用于标识加入容器的对象是一个业务逻辑层的组件
@Controller 同@Component , 主要用于标识加入容器的对象是一个控制层的组件
@Resource 注入属性(DI), 会从容器中找对象注入到@Resource修饰的对象上！
<?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:p="http://www.springframework.org/schema/p"
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">
<!-- 使用注解优化上面 -->
<!--
步骤：
1. 引入context名称空间
2. 开启注解扫描
3. 使用注解
-->
<context:component-scan base-package="cn.itcast.h_anno"></context:component-scan>
</beans>
@Repository
public class UserDao implements IUserDao {
@Override
public void save() {
System.out.println("UserDao.save(), annotation");
}
}
@Service
public class UserService implements IUserService {
@Resource // 根据下面属性名称，去容器里面找对应的对象, 找到后注入进来
private IUserDao userDao;
@Override
public void save() {
userDao.save();
}
}
@Controller
@Scope("prototype") // 指定为多例, 默认为singleton
public class UserAction {
@Resource
private IUserService userService;
public String execute() {
userService.save();
return "success";
}
}
注解与配置的各自优点：
注解，简化配置，开发快捷高效！
配置，开发繁琐、配置麻烦，容易维护！