Spring初探
2017-06-16 本文已影响6人
Acamy丶
可以解决对象创建以及对象之间依赖关系的一种框架
1.第一个Spring程序
1.1 引入jar文件 spring-framework-3.2.5.RELEASE
commons-logging-1.1.3.jar 日志
spring-beans-3.2.5.RELEASE.jar bean节点
spring-context-3.2.5.RELEASE.jar spring上下文节点
spring-core-3.2.5.RELEASE.jar spring核心功能
spring-expression-3.2.5.RELEASE.jar spring表达式相关表
1.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: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">
<!-- IOC容器的配置： 要创建的所有的对象都配置在这里-->
<bean id="user" class="cn.itcast.a_hello.User" init-method="init_user" destroy-method="destroy_user" scope="singleton" lazy-init="false"></bean>
<bean id="user1" class="cn.itcast.a_hello.User"></bean>
</beans>
1.3 测试
测试一：得到IOC容器的两种方法
public class App1_get_ioc {
// 1. 通过工厂类得到IOC容器创建的对象
@Test
public void testIOC() throws Exception {
// 创建对象
// User user = new User();
// 现在，把对象的创建交给spring的IOC容器
Resource resource = new ClassPathResource("cn/acamy/a_hello/applicationContext.xml");
// 创建容器对象(Bean的工厂), IOC容器 = 工厂类 + applicationContext.xml
BeanFactory factory = new XmlBeanFactory(resource);
// 得到容器创建的对象
User user = (User) factory.getBean("user");
System.out.println(user.getId());
}
//2. （方便）直接得到IOC容器对象
@Test
public void testAc() throws Exception {
// 得到IOC容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/acamy/a_hello/applicationContext.xml");
// 从容器中获取bean
User user = (User) ac.getBean("user");
System.out.println(user);
}
}
测试二：相关参数
1) 对象创建： 单例/多例
scope="singleton", 默认值， 即 默认是单例 【service/dao/工具类】
scope="prototype", 多例； 【Action对象】
2) 什么时候创建?
scope="prototype" 在用到对象的时候，才创建对象。
scope="singleton" 在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。
** 3)是否延迟创建**
lazy-init="false" 默认为false, 不延迟创建，即在启动时候就创建对象
lazy-init="true" 延迟初始化， 在用到对象的时候才创建对象
（只对单例有效）
** 4) 创建对象之后，初始化/销毁**
init-method="init_user" 【对应对象的init_user方法，在对象创建爱之后执行 】
destroy-method="destroy_user" 【在调用容器对象的destriy方法时候执行，(容器用实现类)】
public class App2_bean {
@Test
public void testIOC() throws Exception {
// 得到IOC容器对象 【用实现类，因为要调用销毁的方法】
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("cn/acamy/a_hello/applicationContext.xml");
System.out.println("-----容器创建-----");
// 从容器中获取bean
User user1 = (User) ac.getBean("user");
User user2 = (User) ac.getBean("user1");
System.out.println(user1);
System.out.println(user2);
// 销毁容器对象
ac.destroy();
}
}
效果如下：
2. SpringIOC容器
spring核心内容,创建对象 & 处理对象的依赖关系
2.1 创建对象
1） 调用无参数构造器
2） 带参数构造器
3） 工厂创建对象(静态方法和非静态方法)
<!-- 1. 默认无参数构造器 -->
<bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
<!-- 2. 带参数构造器 -->
<bean id="user2" class="cn.itcast.b_create_obj.User">
<constructor-arg index="0" type="int" value="100"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
</bean>
<!-- 定义一个字符串，值是"Jack" ; String s = new String("jack")-->
<bean id="str" class="java.lang.String">
<constructor-arg value="Jacks"></constructor-arg>
</bean>
<bean id="user3" class="cn.itcast.b_create_obj.User">
<constructor-arg index="0" type="int" value="100"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
</bean>
<!-- 3. 工厂类创建对象 -->
<!-- # 3.1 工厂类，实例方法 -->
<!-- 先创建工厂 -->
<bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
<!-- 在创建user对象，用factory方的实例方法 -->
<bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
<!-- # 3.2 工厂类： 静态方法 -->
<!--
class 指定的就是工厂类型
factory-method 一定是工厂里面的“静态方法”
-->
<bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
<!-- 对象写法 -->
<!--
问题：spring配置文件中，bean节点的id与name属性的区别?
id 不能有特殊符号, 且唯一，且不能以数字开始
name 可以有特殊符号
-->
<bean id="1test" name="test" class="cn.itcast.b_create_obj.User"></bean>
2.2 对象依赖关系
2.2.1 通过构造函数
<bean id="user1" class="cn.itcast.c_property.User" scope="prototype">
<constructor-arg value="100"></constructor-arg>
<constructor-arg value="Tom"></constructor-arg>
</bean>
2.2.2 通过set方法给属性注入值
<bean id="user" class="cn.itcast.c_property.User" scope="prototype">
<property name="id" value="101"></property>
<property name="name" value="Jack"></property>
</bean>
2.2.3 bean依赖
<!-- dao instance -->
<bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
<!-- service instance -->
<bean id="userService" class="cn.itcast.c_property.UserService">
<property name="userDao" ref="userDao"></property>
</bean>
<!-- action instance -->
<bean id="userAction1" class="cn.itcast.c_property.UserAction">
<property name="userService" ref="userService"></property>
</bean>
<!-- ##############内部bean############## -->
<bean id="userAction2" class="cn.itcast.c_property.UserAction">
<property name="userService">
<bean class="cn.itcast.c_property.UserService">
<property name="userDao">
<bean class="cn.itcast.c_property.UserDao"></bean>
</property>
</bean>
</property>
</bean>
2.2.4 p名称空间
<bean id="user" class="cn.itcast.c_property.User" p:name="Jack0001"></bean>
<bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
<bean id="userService" class="cn.itcast.c_property.UserService" p:userDao-ref="userDao"></bean>
<bean id="userAction" class="cn.itcast.c_property.UserAction" p:userService-ref="userService"></bean>
2.2.5 自动装配
根据名称自动装配：autowire="byName",自动去IOC容器中找与属性名同名的引用的对象，并自动注入,也可以定义到全局， 这样就不用每个bean节点都去写autowire=”byName”，但必须确保改类型在IOC容器中只有一个对象；否则报错。
<bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>
<bean id="userService" class="cn.itcast.d_auto.UserService" autowire="byName"></bean>
<!-- 根据“名称”自动装配： userAction注入的属性，会去ioc容器中自动查找与属性同名的对象 -->
<bean id="userAction" class="cn.itcast.d_auto.UserAction" autowire="byName"></bean>
2.2.6 注解
注解方式可以简化spring的IOC容器的配置!
需要引入context名称空间并开启注解扫描
xmlns:context="http://www.springframework.org/schema/context"
<context:component-scan base-package="cn.itcast.e_anno2"></context:component-scan>
分类
@Component 指定把一个对象加入IOC容器
@Service 作用同@Component； 在业务逻辑层使用
@Controller 作用同@Component； 在控制层使用
@Repository 作用同@Component； 在持久层使用
@Resource 属性注入
@Component("userAction") // 加入IOC容器，也可以用@Controller
public class UserAction {
@Resource(name = "userService")
private UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
public String execute() {
userService.save();
return null;
}
}
@Component("userService") // userService加入ioc容器，也可以用@Service
public class UserService {
// 会从IOC容器中找userDao对象，注入到当前字段
/*
* <bean id="" class="">
* <property name="userDao" ref="userDao" /> @Resource相当于这里的配置
* </bean>
*/
@Resource(name = "userDao")
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void save() {
userDao.save();
}
}
// 把当前对象加入ioc容器
@Component("userDao") //也可以用Repository 相当于bean.xml 【<bean id=userDao class=".." />】
public class UserDao {
public void save() {
System.out.println("DB:保存用户!!!");
}
}
