IOC 操作 Bean 管理
-
什么是 Bean 管理
(0)Bean 管理指的是两个操作
(1)Spring 创建对象
(2)Spirng 注入属性 -
Bean 管理操作有两种方式
(1)基于 xml 配置文件方式实现
(2)基于注解方式实现
IOC 操作 Bean 管理(基于 xml 方式创建对象)
-
基于 xml 方式创建对象
-
基于 xml 方式注入属性
(1)DI:依赖注入,就是注入属性
第一种注入方式:使用 set 方法进行注入第二种注入方式:使用有参数构造进行注入
演示普通方法
public class Book {
private String bname;
public Book() {
}
//set方式注入
public void setBname(String bname) {
this.bname = bname;
}
//有参数构造注入
public Book(String bname){
this.bname=bname;
}
//调用
public static void main(String[] args){
Book book = new Book();
book.setBname("newbook");
Book book1 = new Book("abc");
}
}
spring的做法:1.set方式注入
public class Book {
//创建属性
private String bname;
private String bauthor;
//创建属性对应的 set 方法
public void setBname(String bname) {
this.bname = bname;
}
public void setBauthor(String bauthor) {
this.bauthor = bauthor;
}
public void testBook(){
System.out.println("IOC通过set方式注入参数。。。。。"+bname+bauthor);
}
}
//xml配置bean
<bean id="book" class="com.spring5.pojo.Book">
<property name="bname" value="如来神掌"></property>
<property name="bauthor" value="九阴真经"></property>
</bean>
//测试
@Test
public void ioctest(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
Book book = (Book)context.getBean("book");
book.testBook();
}
spring的做法:.有参构造方式注入
public class Oder {
//属性
private String oname;
private String address;
//有参数构造
public Oder(String oname, String address) {
this.oname = oname;
this.address = address;
}
public void testConstruct(){
System.out.println("IOC通过有参构造方式注入。。。"+oname+address);
}
}
//测试
@Test
public void construct(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
Oder oder = (Oder)context.getBean("oder");
oder.testConstruct();
}
-
p 名称空间注入
IOC 操作 Bean 管理(xml 注入其他类型属性) -
1、字面量
(1)null 值
(2)属性值包含特殊符号
1 把<>进行转义 < >
2 把带特殊符号内容写到 CDATA
<!--null 值-->
<property name="address">
<null/>
</property>
<property name="address">
<value><![CDATA[<<南京>>]]></value>
</property>
- 2、注入属性-外部 bean
Service
public class UserService {
private UserDaos userDaos;
public void setUserDaos(UserDaos userDaos) {
this.userDaos = userDaos;
}
public void add(){
System.out.println("UserService.....add....");
userDaos.update();
}
}
//Dao
public interface UserDaos {
public void update();
}
//DaoImpl
public class UserDaosImpl implements UserDaos{
@Override
public void update() {
System.out.println("UserDao.....update");
}
}
//bean
<bean id="userService" class="com.spring5.service.UserService">
<property name="userDaos" ref="userDaosImpl"></property>
</bean>
<bean id="userDaosImpl" class="com.spring5.dao.UserDaosImpl"></bean>
//测试
@Test
public void beanTest(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
UserService userService = (UserService)context.getBean("userService");
userService.add();
}
- 3、注入属性-内部 bean
(1)一对多关系:部门和员工
一个部门有多个员工,一个员工属于一个部门
部门是一,员工是多
(2)在实体类之间表示一对多关系,员工表示所属部门,使用对象类型属性进行表示
//部门类
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
}
//员工类
public class Emp {
private String ename;
private String gender;
//员工属于某一个部门,使用对象形式表示
private Dept dept;
public void setDept(Dept dept) {
this.dept = dept;
}
public void setEname(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;
}
}
(3)在 spring 配置文件中进行配置
<!--内部 bean-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!--设置对象类型属性-->
<property name="dept">
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
<property name="dname" value="安保部"></property>
</bean>
</property>
</bean>
IOC 操作 Bean 管理(xml 注入集合属性)
1、注入数组类型属性
2、注入 List 集合类型属性
3、注入 Map 集合类型属性
(1)创建类,定义数组、list、map、set 类型属性,生成对应 set 方法
public class Stu {
//1 数组类型属性
private String[] courses;
//2 list 集合类型属性
private List<String> list;
//3 map 集合类型属性
private Map<String,String> maps;
//4 set 集合类型属性
private Set<String> sets;
public void setSets(Set<String> sets) {
this.sets = sets;
}
public void setCourses(String[] courses) {
this.courses = courses;
}
public void setList(List<String> list) {
this.list = list;
}
public void setMaps(Map<String, String> maps) {
this.maps = maps;
}
}
(2)在 spring 配置文件进行配置
<!--1 集合类型属性注入-->
<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
<!--数组类型属性注入-->
<property name="courses">
<array>
<value>java 课程</value>
<value>数据库课程</value>
</array>
</property>
<!--list 类型属性注入-->
<property name="list">
<list>
<value>张三</value>
<value>小三</value>
</list>
</property>
<!--map 类型属性注入-->
<property name="maps">
<map>
<entry key="JAVA" value="java"></entry>
<entry key="PHP" value="php"></entry>
</map>
</property>
<!--set 类型属性注入-->
<property name="sets">
<set>
<value>MySQL</value>
<value>Redis</value>
</set>
</property>
</bean>
IOC 操作 Bean 管理(FactoryBean)
- Spring 有两种类型 bean,一种普通 bean,另外一种工厂 bean(FactoryBean)
1、普通 bean:在配置文件中定义 bean 类型就是返回类型
定义userdao就只能得到userdao
2、工厂 bean:在配置文件定义 bean 类型可以和返回类型不一样
第一步 创建类,让这个类作为工厂 bean,实现接口 FactoryBean
第二步 实现接口里面的方法,在实现的方法中定义返回的 bean 类型
```java
public class MyBean implements FactoryBean {
//定义返回bean
@Override
public Object getObject() throws Exception {
Cat cat = new Cat();
cat.setColor("red");
return cat;
}
@Override
public Class<?> getObjectType() {
return null;
}
}
//xml
<!-- 工厂bean-->
<bean id="factoryBean" class="com.spring5.factorybean.MyBean"></bean>
//测试
@Test
public void factoryTest(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
Cat cat = (Cat)context.getBean("factoryBean");
System.out.println(cat);
}
IOC 操作 Bean 管理(bean 作用域)
1、在 Spring 里面,设置创建 bean 实例是单实例还是多实例
在 Spring 里面,默认情况下,bean 是单实例对象
2、如何设置单实例还是多实例
(1)在 spring 配置文件 bean 标签里面有属性(scope)用于设置单实例还是多实例
(2)scope 属性值
第一个值 默认值,singleton,表示是单实例对象
第二个值 prototype,表示是多实例对象
(3)singleton 和 prototype 区别
singleton 单实例,prototype 多实例
设置 scope 值是 singleton 时候,加载 spring 配置文件时候就会创建单实例对象
设置 scope 值是 prototype 时候,不是在加载 spring 配置文件时候创建 对象,在调用
getBean 方法时候创建多实例对象
IOC 操作 Bean 管理(bean 生命周期)
<bean id="orders" class="com.atguigu.spring5.bean.Orders" initmethod="initMethod" destroy-method="destroyMethod">
<property name="oname" value="手机"></property>
</bean>
IOC 操作 Bean 管理(xml 自动装配)
1、什么是自动装配
(1)根据指定装配规则(属性名称或者属性类型),Spring 自动将匹配的属性值进行注入
下面就是手动装配
<bean id="emp" class="com.spring5.autowire.Emp">
<property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.spring5.autowire.Dept"></bean>
//部门
public class Dept {
}
//员工
public class Emp {
private Dept dept;
public void setDept(Dept dept) {
this.dept = dept;
}
@Override
public String toString() {
return "Emp{" +
"dept=" + dept +
'}';
}
public void test(){
System.out.println(dept);
}
}
//测试
@Test
public void fautoTest(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
Emp emp = (Emp)context.getBean("emp");
System.out.println(emp);
}
>>>>Emp{dept=com.spring5.autowire.Dept@37374a5e}
2、演示自动装配过程
(1)根据属性名称自动注入
实现自动装配
bean 标签属性 autowire,配置自动装配
autowire 属性常用两个值:
byName 根据属性名称注入 ,注入值 bean 的 id 值和类属性名称一样
byType 根据属性类型注入
<bean id="emp" class="com.spring5.autowire.Emp" autowire="byName">
<!-- <property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.spring5.autowire.Dept"></bean>
IOC 操作 Bean 管理(外部属性文件)
- 1.直接配置数据库信息
(1)配置德鲁伊连接池
(2)引入德鲁伊连接池依赖 jar 包
<!--直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url"value="jdbc:mysql://localhost:3306/userDb"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
- 2.引入外部属性文件配置数据库连接池
(1)创建外部属性文件,properties 格式文件,写数据库信息
在 spring 配置文件使用标签引入外部属性文件
<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${prop.driverClass}"></property>
<property name="url" value="${prop.url}"></property>
<property name="username" value="${prop.userName}"></property>
<property name="password" value="${prop.password}"></property>
</bean>
IOC 操作 Bean 管理(基于注解方式创建对象)
1、什么是注解
(1)注解是代码特殊标记,格式:@注解名称(属性名称=属性值, 属性名称=属性值…)
(2)使用注解,注解作用在类上面,方法上面,属性上面
(3)使用注解目的:简化 xml 配置
2、Spring 针对 Bean 管理中创建对象提供注解
(1)@Component
(2)@Service
(3)@Controller
(4)@Repository
- 上面四个注解功能是一样的,都可以用来创建 bean 实例
第一步 引入依赖
第二步 开启组件扫描
<?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">
<!-- 开启组件扫描
1 如果扫描多个包,多个包使用逗号隔开
2 扫描包上层目录-->
<!-- <context:component-scan base-package="com.spring5"></context:component-scan>-->
<context:component-scan base-package="com.spring5.service,com.spring5.service"></context:component-scan>
</beans>
第三步 创建类,在类上面添加创建对象注解
import org.springframework.stereotype.Component;
//在注解里value值可以不写
//默认值是类名称,首字母小写
@Component(value = "userService") //相当于<bean id="userService" class="../>
public class UserService {
public void add(){
System.out.println("service add......");
}
}
//测试
public class TestSpring5 {
@Test
public void addTest(){
// IOC 控制反转 实现的两种方式--接口
// IOC容器基本实现方式 是Spring内部使用接口 不提供开发人员使用
//* 加载配置文件时候不会创建对象,在获取对象(使用)才去创建对象
BeanFactory Context1 = new ClassPathXmlApplicationContext("bean1.xml"); //加载配置文件
//BeanFactory的子接口,功能更强大 面向开发人员
//* 加载配置文件时候就会把在配置文件对象进行创建
ApplicationContext Context = new ClassPathXmlApplicationContext("bean1.xml"); //加载配置文件
UserService userService = (UserService) Context.getBean("userService");
System.out.println(userService);
userService.add();
}
}
4、开启组件扫描细节配置
<!--示例 1
use-default-filters="false" 表示现在不使用默认 filter,自己配置 filter
context:include-filter ,设置扫描哪些内容
-->
<context:component-scan base-package="com.atguigu" use-defaultfilters="false">
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--示例 2
下面配置扫描包所有内容
context:exclude-filter: 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.atguigu">
<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
5、基于注解方式实现属性注入
(1)@Autowired:根据属性类型进行自动装配
第一步 把 service 和 dao 对象创建,在 service 和 dao 类添加创建对象注解
第二步 在 service 注入 dao 对象,在 service 类添加 dao 类型属性,在属性上面使用注解
//先xml扫描
<context:component-scan base-package="com.spring5"></context:component-scan>
@Service
public class UserService {
//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired
private UserDao userDao;
public void add() {
System.out.println("service add.......");
userDao.add();
}
}
//Dao
public interface UserDao {
public void add();
}
//DaoImpl
@Repository
public class UserDaoImpl implements UserDao{
@Override
public void add() {
System.out.println("dao...........add");
}
}
//测试
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
UserService userService = (UserService) context.getBean("userService");
userService.add();
}
(2)@Qualifier:根据名称进行注入
这个@Qualifier 注解的使用,和上面@Autowired 一起使用
//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;
(3)@Resource:可以根据类型注入,可以根据名称注入
//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;
(4)@Value:注入普通类型属性
@Value(value = "abc")
private String name;
6、完全注解开发
(1)创建配置类,替代 xml 配置文件
@Configuration //作为配置类,替代 xml 配置文件
@ComponentScan(basePackages = {"com.atguigu"})
public class SpringConfig {
}
(2)编写测试类
@Test
public void testService2() {
//加载配置类
ApplicationContext context
= new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService",
UserService.class);
System.out.println(userService);
userService.add();
}