栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring(一):Bean管理和对象的生命周期

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring(一):Bean管理和对象的生命周期

文章目录
  • 一、Spring概述
  • 二、IOC 依赖注入
  • 三、IOC之基于 XML 管理Bean
    • 3.1 通过id获取对象(重点)
    • 3.2 通过类型获取对象
    • 3.3 通过构造方法参数名注入值
    • 3.4 index属性指定参数的位置
    • 3.5 根据参数类型注入
    • 3.6 IOC之 P名称空间
    • 3.7 测试null值的使用
    • 3.8 IOC之子对象的赋值测试
    • 3.9 IOC之内部Bean的使用
    • 3.10 IOC之List属性的赋值
    • 3.11 IOC之Map属性的赋值
    • 3.12 IOC之Properties属性的赋值
    • 3.13 IOC之util 名称空间
    • 3.14 IOC之级联属性赋值
    • 3.15 IOC之静态工厂方法创建Bean
    • 3.16 IOC之工厂实例方法创建Bean
    • 3.17 IOC之FactoryBean接口方式创建对象
    • 3.18 IOC之继承Bean配置
    • 3.19 IOC之abstract抽象Bean
    • 3.20 IOC之组件创建顺序
    • 3.21 IOC之Bean的单例和多例
    • 3.22 基于xml配置文件的自动注入
  • 四、对象的生命周期
    • 4.1 IOC之Bean的生命周期
    • 4.2 Bean的后置处理器BeanPostProcessor
  • 五、IOC之基于注解管理Bean

一、Spring概述

Spring是一个开源框架,为简化企业级开发而生,使用Spring开发可以将Bean对象,Dao组件对象,Service组件对象等交给Spring容器来管理,这样使得很多复杂的代码在Spring中开发却变得非常的优雅和简洁,有效的降低代码的耦合度,极大的方便项目的后期维护、升级和扩展。

Spring是一个IOC(DI)和AOP容器框架。

Spring的优良特性:

  1. 非侵入式:基于Spring开发的应用中的对象可以不依赖于Spring的API;
  2. 控制反转:IOC——Inversion of Control,指的是将对象的创建权交给Spring去创建。使用Spring之前,对象的创建都是由我们自己在代码中new创建。而使用Spring之后。对象的创建都是由给了Spring框架。
  3. 依赖注入:DI——Dependency Injection,是指依赖的对象不需要手动调用setXX方法去设置,而是通过配置赋值。
  4. 面向切面编程:Aspect Oriented Programming——AOP
  5. 容器:Spring是一个容器,因为它包含并且管理应用对象的生命周期
  6. 组件化:Spring实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用XML和Java注解组合这些对象。
  7. 一站式:在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库(实际上Spring 自身也提供了表现层的SpringMVC和持久层的Spring JDBC)。
二、IOC 依赖注入

什么是 IOC?

  1. 控制反转,把对象创建和对象之间的调用过程,交给 Spring 进行管理
  2. 使用 IOC 目的:为了耦合度降低
  3. 做入门案例就是 IOC 实现

IOC 底层原理

xml 解析、工厂模式、反射

IOC(BeanFactory 接口)

IOC 思想基于 IOC 容器完成,IOC 容器底层就是对象工厂。

Spring 提供 IOC 容器实现两种方式:(两个接口)

  • BeanFactory:IOC 容器基本实现,是 Spring 内部的使用接口,不提供开发人员进行使用
    • 加载配置文件时候不会创建对象,在获取对象(使用)才去创建对象
  • ApplicationContext:BeanFactory 接口的子接口,提供更多更强大的功能,一般由开发人员进行使用
    • 加载配置文件时候就会把在配置文件对象进行创建

ApplicationContext 接口有实现类

IOC 操作 Bean 管理(概念)

什么是 Bean 管理?Bean 管理指的是两个操作

  • Spring 创建对象
  • Spirng 注入属性

Bean 管理操作有两种方式

  • 基于 xml 配置文件方式实现
  • 基于注解方式实现

什么是DI?

DI 指的是Dependency Injection 。是依赖注入的意思。

使用Spring之前需要通过代码进行注入赋值,使用Spring以后只需要进行配置赋值。

简单点说,就是给一个对象中依赖的另一个对象赋值。

三、IOC之基于 XML 管理Bean 3.1 通过id获取对象(重点)



    
    
            
        
        
        
        
    


@Test
public void test1() {
    // 首先需要有一个Spring IOC 容器对象。在spring中一个接口就表示了这个Spring IOC窗口对象
    // ClassPathXmlApplicationContext类表示从Classpath类路径下加载xml配置文件创建SpringIOC容器对象
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 从Spring IOC容器中获取一个id为p1的对象
    Person person = (Person) applicationContext.getBean("p1");
    System.out.println( person );
}
3.2 通过类型获取对象
@Test
public void test2() throws Exception {
    // 首先需要有一个Spring IOC 容器对象。在spring中一个接口就表示了这个Spring IOC窗口对象
    // ClassPathXmlApplicationContext类表示从Classpath类路径下加载xml配置文件创建SpringIOC容器对象
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 从Spring IOC容器中获取一个id为p1的对象
    
    Person person = (Person) applicationContext.getBean(Person.class);
    System.out.println( person );
}
3.3 通过构造方法参数名注入值

    
    
    
    
    

3.4 index属性指定参数的位置

    
    
    
    
    

3.5 根据参数类型注入

    
    
    
    

3.6 IOC之 P名称空间





    
    
3.7 测试null值的使用

    
    
    
        
    
    


    
    
    
        
    
    

3.8 IOC之子对象的赋值测试

    
    



    
    
    
    

@Test
public void test8() throws Exception {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    //Boss(id=8, name=马云, car=Car(carNo=京B123412, name=蓝波基泥))
    System.out.println( applicationContext.getBean("p8") );
}
3.9 IOC之内部Bean的使用

    
    
    
        
        
            
            
        
    

@Test
public void test9() throws Exception {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    //Boss(id=9, name=马云, car=Car(carNo=京B123411, name=奇锐))
    System.out.println( applicationContext.getBean("p9") );
    //Car(carNo=京B123412, name=蓝波基泥)
    System.out.println( applicationContext.getBean("car01") );
    //No bean named 'car02' available
    System.out.println( applicationContext.getBean("car02") );
}
3.10 IOC之List属性的赋值

    
    
    
        
            string1
            string2
            string3
        
    

3.11 IOC之Map属性的赋值

    
    
    
        
            
            
            
        
    

3.12 IOC之Properties属性的赋值
    
        
        
        
            
                root
                jdbc:mysql://localhost:3306/test
            
        
    
3.13 IOC之util 名称空间



       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">  
    




    易筋经
    九阴真经
    九阳神功




    

3.14 IOC之级联属性赋值

    
    
    

@Test
public void test10() throws Exception {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    //Emp(id=null, name=null, car=Car(carNo=京B123412, name=级联属性赋值), list=null, map=null, properties=null)
    System.out.println( applicationContext.getBean("p14") );
}
3.15 IOC之静态工厂方法创建Bean

工厂代码:

public class PersonFactory {

	public static Person createPerson() {
		return new Person(null, "静态工厂方法创建的person对象", null);
	}
	
}


3.16 IOC之工厂实例方法创建Bean

工厂代码:

public class PersonFactory {

	public Person createPerson2() {
		return new Person(null, "工厂实例方法创建的person对象", null);
	}

}




3.17 IOC之FactoryBean接口方式创建对象

工厂代码:

public class PersonFactory {

	public Person createPerson2() {
		return new Person(null, "工厂实例方法创建的person对象", null);
	}

}




3.18 IOC之继承Bean配置

    
    



    
    
    




    

3.19 IOC之abstract抽象Bean


	
	
	

3.20 IOC之组件创建顺序
public class A {
	public A() {
		System.out.println("我是A妹妹");
	}
}
public class B {
	public B() {
		System.out.println("我是B");
	}
}
public class C {
	public C() {
		System.out.println("我是C");
	}
}



    
    
    
    

@Test
public void test12() throws Exception {
	// 我是B
	// 我是C
	// 我是A
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean2.xml");
}
3.21 IOC之Bean的单例和多例
scope属性作用域范围
singleton默认值,单例
1、会在Spring IOC容器被创建的时候创建。
2、每次调用getBean方法都会获取之前创建的对象
prototype多例
1、多例的bean对象,不会随着容器对象的创建而创建。
2、每次调用getBean方法都会创建一个Person对象
request是指,每次调用getBean对象,只要是同一个请求,每次都返回同一个对象
getBean() 原理:
Object bean = request.getAttribute(id);
if (bean == null) {
bean = new Object();
request.setAttribute( id,bean );
}
return bean;
session只要当前是相同的一个会话对象,不管调用多少次的getBean,都会返回同一个bean对象
getBean() 原理:
Object bean = session.getAttribute(id);
if (bean == null) {
bean = new Object();
session.setAttribute( id,bean );
}
return bean;

3.22 基于xml配置文件的自动注入

先创建Person类和Car类

public class Car {

	private String name;
}
public class Person {

	private Car car;

	public Person(Car car) {
		this.car = car;
	}
}


	

四、对象的生命周期 4.1 IOC之Bean的生命周期
  1. 通过构造器创建 bean 实例(无参数构造)
  2. 为 bean 的属性设置值和对其他 bean 引用(调用 set 方法)
  3. 调用 bean 的初始化的方法(需要进行配置初始化的方法)
  4. bean 可以使用了(对象获取到了)
  5. 当容器关闭时候,调用 bean 的销毁的方法(需要进行配置销毁的方法)

创建带有生命周期方法的bean:

public class Orders {

    public Orders() {
        System.out.println("第一步 执行无参数构造创建 bean 实例");
    }

    private String name;

    public void setName(String name) {
        this.name = name;
        System.out.println("第二步 调用 set 方法设置属性值");
    }

    //创建执行的初始化的方法
    public void initMethod() {
        System.out.println("第三步 执行初始化的方法");
    }

    //创建执行的销毁的方法
    public void destroyMethod() {
        System.out.println("第五步 执行销毁的方法");
    }
}

配置信息:


    

测试代码:

@Test
public void testBean3() {
    ClassPathXmlApplicationContext context =
            new ClassPathXmlApplicationContext("bean2.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("第四步 获取创建 bean 实例对象");
    System.out.println(orders);
    //手动让 bean 实例销毁
    context.close();
}
4.2 Bean的后置处理器BeanPostProcessor

bean的后置处理器,可以在bean对象初始化之前或之后做一些工作。要使用bean的后置处理器,需要实现这个接口并配置。

bean 的后置处理器,bean 生命周期有七步

  1. 通过构造器创建 bean 实例(无参数构造)
  2. 为 bean 的属性设置值和对其他 bean 引用(调用 set 方法)
  3. 把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization
  4. 调用 bean 的初始化的方法(需要进行配置初始化的方法)
  5. 把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
  6. bean 可以使用了(对象获取到了)
  7. 当容器关闭时候,调用 bean 的销毁的方法(需要进行配置销毁的方法)

后置处理器对象

public class MyBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessAfterInitialization(Object bean, String id) throws BeansException {
		System.out.println("初始化之后执行  bean => " + bean + ", id => " + id);
		return bean;
	}
	
	@Override
	public Object postProcessBeforeInitialization(Object bean, String id) throws BeansException {
		System.out.println("初始化之前执行  bean => " + bean + ", id => " + id);
		return bean;
	}

}

配置信息:


    



@Test
public void test13() throws Exception {
    //初始化之后执行  bean => com.hc.boot.life.Person@7baf6acf, id => p24
    //这是person对象的初始化方法
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean2.xml");
    //初始化之前执行  bean => com.hc.boot.life.Person@7baf6acf, id => p24
    //com.hc.boot.life.Person@7b3315a5
    System.out.println(applicationContext.getBean("p24"));
    //这是person对象的销毁方法
    applicationContext.close();
}
五、IOC之基于注解管理Bean

1、Spring 针对 Bean 管理中创建对象提供注解

下面四个注解功能是一样的,都可以用来创建 bean 实例

  • @Component
  • @Service
  • @Controller
  • @Repository

2、基于注解方式实现对象创建

​ 第一步 引入依赖 (引入spring-aop jar包)

​ 第二步 开启组件扫描



​ 第三步 创建类,在类上面添加创建对象注解

//在注解里面 value 属性值可以省略不写,
//默认值是类名称,首字母小写
//UserService -- userService
@Component(value = "userService") //注解等同于XML配置文件:
	public class UserService {
		public void add() {
		System.out.println("service add.......");
	}
}

​ 3、开启组件扫描细节配置



 



 

4、基于注解方式实现属性注入

@Autowired:根据属性类型进行自动装配

第一步 把 service 和 dao 对象创建,在 service 和 dao 类添加创建对象注解

第二步 在 service 注入 dao 对象,在 service 类添加 dao 类型属性,在属性上面使用注解

@Service
public class UserService {
	//定义 dao 类型属性
	//不需要添加 set 方法
	//添加注入属性注解
	@Autowired
	private UserDao userDao;
	public void add() {
	 System.out.println("service add.......");
	 userDao.add();
	}
}

//Dao实现类
@Repository
//@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        System.out.println("dao add.....");
    }
}

@Qualifier:根据名称进行注入,这个@Qualifier 注解的使用,和上面@Autowired 一起使用

//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
//根据名称进行注入(目的在于区别同一接口下有多个实现类,根据类型就无法选择,从而出错!)
@Qualifier(value = "userDaoImpl1") 
private UserDao userDao;

@Resource:可以根据类型注入,也可以根据名称注入(它属于javax包下的注解,不推荐使用!)

//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

@Value:注入普通类型属性

@Value(value = "abc")
private String name

5、完全注解开发

创建配置类,替代 xml 配置文件

@Configuration //作为配置类,替代 xml 配置文件
@ComponentScan(basePackages = {"com.atguigu"})
public class SpringConfig {
    
}

编写测试类

@Test
public void testService2() {
 //加载配置类
 ApplicationContext context
 = new AnnotationConfigApplicationContext(SpringConfig.class);
 UserService userService = context.getBean("userService",
UserService.class);
 System.out.println(userService);
 userService.add();
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/940390.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号