基于xml配置对象容器——xml 标签说明
alias标签
作用:为已配置的bean设置别名
—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">
<bean id="user" class="org.cjw.pojo.User" />
<!--
标签alias:为已配置的bean设置别名
name属性:必要属性,代表为哪一个bena配置别名
此属性的值为其他bean标签的id或name属性值
alias属性:必要属性,代表新命名的别名是什么
-->
<alias name="user" alias="user1" />
</beans>
—测试代码
package org.cjw.pojo.test;
import org.cjw.pojo.User;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class UserTest {
@Test
public void testAlias() {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
// 通过id获取User对象
User user = context.getBean("user", User.class);
System.out.println(user);
System.out.println("-----------------");
// 通过别名获取User对象
User user2 = context.getBean("user1", User.class);
System.out.println(user2);
}
}
—测试结果
bean标签的配置
5.2.1. bean标签作用
用于声明一个类,在启动Spring框架的时候根据配置信息创建对象到Spring容器里面。
5.2.2. 属性说明
<?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">
<!--
<bean>标签:用于声明一个类,在启动Spring框架的时候配置信息创建对象到spring容器里面去
name属性:设置对象名(唯一标识符),可以有多个名称,每一个名称用逗号隔开,如name1,name2
id属性:设置对象名(唯一标识符),功能和name一样,但是id只能有一个
class属性:用于指定对象对应的类名,用于反射创建对象
scope属性:用于设置对象的作用范围,可选参数如下:
*singleton:单例(默认)
对象出生:当程序加载配置文件创建容器时,创建
对象活着:只要容器还在,一直活着
对象死亡:应用停止,容器销毁,对象死亡
*propertype:多例(原型对象)
对象出生:当程序加载配置文件创建容器时,创建
对象活着:只要对象被使用,一直活着
对象死亡:对象长时间不用,会被java立即回收机制回收
*request:web项目中,Spring将创建的对象放在request作用域中
*session:web项目中,Spring将创建的对象放在session作用域中
-->
<bean id="customerServiceImpl" class="org.cjw.service.impl.CustomerServiceImpl" scope="singleton" />
</beans>
5.2.3. Bean作用范围
作用范围也可以说生命周期(bean能存活多久)
![基于xml配置对象容器 - 图2](/uploads/projects/yangguangfanxing@vypvaf/78eac1994e7cbd781158b336cf1b4d4e.jpeg)
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">
<!--
<bean id="" class="" scope="作用域"/>
scope : 配置当前bean的范围大小
singleton: 单例 ,在Spring IoC容器中仅存在一个Bean实例 (默认的scope)
prototype: 多例 ,每次从容器中调用Bean时,都返回一个新的实例,即每次调用getBean()时 ,相当于执行new XxxBean()
-->
<bean id="customerServiceImpl" class="org.cjw.service.impl.CustomerServiceImpl" scope="prototype" />
</beans>
在Web开发的三层架构中
- Web:一般都是多例
- Service:单例
- DAO:单例
如果使用struct,那么会在表示层使用成员变量来接受前端发送过来的参数,此时如果表示层使用的是单例,那么会造成数据的错乱,所以表示层需要使用多例。
而现在springMVC已经不再使用成员变量来接受前端参数了,而是直接对应方法的参数,所以表示层可以使用单例,因为方法的参数是在程序运行过程中才会被赋值,所以不存在数据错乱的问题,因此可以使用单例。
单例和多例的使用判断准则:是否存在共享数据情况,如果有,使用多例,没有则单例。如果使用了单例还存在共享数据的情况,那么就需要使用锁来保证数据的正确性。
## 实例化Bean的四种方式
Spring创建对象的四种方式
### 5.3.1. 构造器实例化(无参数构造器),最标准,使用最多。
java
package org.cjw.pojo;
public class SomeBean1 {
public SomeBean1() {
System.out.println("SomeBean.SomeBean1()");
}
}
—配置文件
xml
<!-- ①构造器实例化(无参构造器),最标准、使用最多 -->
<bean id="someBean1" class="org.cjw.pojo.SomeBean1"/>
### 5.3.2. 通过静态方法工厂创建(了解)
—bean、静态工厂类
java
SomeBean2、SomeBean2Factory
public class SomeBean2 {
public SomeBean2() {
System.out.println("SomeBean.SomeBean2()");
}
}
public class SomeBean2Factory {
public static SomeBean2 getSomeBean2() {
System.out.println("执行静态工厂方法");
return new SomeBean2();
}
}
—静态工厂配置
xml
<!-- ②.静态工厂方法实例化:解决系统遗留问题 -->
<bean id="someBean2" class="org.cjw.factory.SomeBean2Factory" factory-method="getSomeBean2" />
### 5.3.3. 通过实例工厂创建(了解)
—实体工厂
java
public class SomeBean3 {
public SomeBean3() {
System.out.println("SomeBean.SomeBean3()");
}
}
public class SomeBean3Facotry {
//实例工厂方法
public SomeBean3 getSomeBean3() {
System.out.println("执行实例工厂方法");
return new SomeBean3();
}
}
—配置方式
xml
<!-- 1.配置工厂bean -->
<bean id="someBean3Factory" class="org.cjw.factory.SomeBean3Facotry"></bean>
<!-- 2.配置bena
factory-bean : 创建bean的工厂对象对应的 id
factory-method : 工厂bean中返回 bean对象的方法
-->
<bean id="someBean3" factory-bean="someBean3Factory" factory-method="getSomeBean3"/>
### 5.3.4. 实现FactoryBean接口实例化:实例工厂变种(了解)
实现FactoryBean接口,MyBatis和Spring集成就是使用的这种方式。
此种方式,如果没有使用Bean对应的对象,Spring就不会自动创建,只有在使用的时候Spring才会创建对应的对象。
java
public class SomeBean4 {
public SomeBean4() {
System.out.println("SomeBean4.SomeBean4()");
}
}
public class SomeBean4ObjectFactory implements FactoryBean<SomeBean4> {
@Override
public SomeBean4 getObject() throws Exception {
SomeBean4 bean4 = new SomeBean4();
return bean4;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return false;
}
}
—配置方式
xml
<!-- ④.实现FactoryBean接口实例化:实例工厂变种:集成其他框架使用:LocalSessionFactoryBean -->
<bean id="someBean4" class="org.cjw.factory.SomeBean4ObjectFactory" />
## 初始化和销毁方法
比如DataSource,SessionFactory最终都需要关闭资源:在Bean销毁之前,都要调用close方法.
xml
<bean id="someBean" class="......"
init-method="该类中初始化方法名" destroy-method="该类中销毁方法名">
</bean>
init-method:bean生命周期初始化方法,对象创建后就进行调用
destroy-method:容器被销毁的时候,如果bean被容器管理,会调用该方法。
default-init-method:指定默认的初始化方法
分析原理:
如果bean的scope=”prototype”,那么容器只负责创建和初始化,它并不会被spring容器管理。交给用户自己调用。
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"
default-init-method="init">
<!--
配置全局初始化方法,如果有100个bean中都有init方法,那么只要Spring容器一启动,bean对象一创建
默认对象中只要有 init方法,都全部会执行:一般不建议使用
-->
<!--
init-method : 配置初始化方法名
destroy-method : 配置销毁方法名
-->
<bean id="someBean" class="org.cjw.pojo.SomeBean1" init-method="init" destroy-method="destory" />
</beans>
# 获得properties文件的值
Spring配置文件支持通过xxx.properties文件的Key获得对应的值。实现该功能是通过${Key}来获得Properties文件指定Key的Value值。
使用Spring读取配置文件必须导入新的命名空间(context)。
导入命名空间方法:将命名空间和约束重新拷贝一份,将对应的全部替换成 context,然后关联context本地schema约束。
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">
## 使用Spring创建阿里巴巴 Druid连接池(读取配置文件)
### 7.1.1. 拷贝Mysql驱动包和druid连接池jar包到项目中
![基于xml配置对象容器 - 图3](/uploads/projects/yangguangfanxing@vypvaf/e794a58f4dc34d30a43823f7b4a13093.png)
properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/users
jdbc.username=root
jdbc.password=root
jdbc.maxActive=10
### 7.1.3. applicationContext.xml配置
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">
<!-- 读取classpath下的db.properties配置文件 -->
<context:property-placeholder location="classpath:db.properties" />
<!-- 配置数据源 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<property name="maxActive" value="${jdbc.maxActive}" />
</bean>
</beans>
### 7.1.4. 测试代码
java
@Test
public void testAlias() {
try {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
DataSource dataSource = context.getBean("dataSource", DataSource.class);
Connection connection = dataSource.getConnection();
System.out.println(connection);
} catch (SQLException e) {
e.printStackTrace();
}
}
### 7.1.5. 效果
![基于xml配置对象容器 - 图4](/uploads/projects/yangguangfanxing@vypvaf/6629abe8182d4400cf62bb16d62a7d33.jpeg)
java
public interface UserDao {
public void insert(User user);
}
public class UserDaoImpl implements UserDao {
@Override
public void insert(User user) {
System.out.println("注册功能Dao层方法执行了");
}
}
## Service层接口以及实现代码
java
public interface UserService {
void insert(User user);
}
public class UserServiceImpl implements UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void insert(User user) {
System.out.println("注册功能Service层方法执行了");
userDao.insert(user);
}
}
## Web表现层实现代码
java
package org.cjw.controller;
import org.cjw.pojo.User;
import org.cjw.service.UserService;
public class UserController {
private UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
public void insert() {
System.out.println("注册功能Controller层方法执行了");
User user = new User();
userService.insert(user);
}
}
## applicationContext.xml文件配置代码
(重点),一定要掌握每层的配置,和每层之间对象的依赖关系的维护
```xml
<?xml version=”1.0” encoding=”UTF-8”?>
<bean id="userService" class="org.cjw.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao" />
</bean>
<bean id="userDao" class="org.cjw.dao.impl.UserDaoImpl" />
<a name="4f036ee1"></a>
## 测试代码
```java
@Test
public void testAlias() {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserController userController = context.getBean("userController", UserController.class);
userController.insert();
}
测试结果
小结
1. 基于xml和ClassPathXmlApplicationContext配置容器
2. Spring读取 .Properteis配置文件
3. 综合案例-模拟注册功能-使用Spring管理对象