springIOC容器基本用法

最新推荐文章于 2024-08-20 16:01:03 发布

sunpy 孙培煜

最新推荐文章于 2024-08-20 16:01:03 发布

阅读量3.4k

点赞数 4

分类专栏： _____3.4 spring

本文链接：https://blog.csdn.net/ya_1249463314/article/details/53153030

版权

_____3.4 spring 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.springIOC到底是什么？

重要的就是用来完成对对象的创建以及依赖注入的管理等。按照我们以前的编程方式，需要对象就直接new即可，然后为对象和构造方法及方法等赋值，需要对象的创建对象，需要方法则调用方法，然后再去设置参数，而spring为我们把这些事都省略了，简化了我们的操作，那么就都由spring来为我们管理，直接帮我们注入，所以这个就是所谓的依赖注入。

2.搭建环境

spring肯定不会无缘无故从天而降，肯定需要导入相关的jar包，而spring也需要我们的提示，才会按需注入，所以肯定需要相关的配置来告诉spring如何配置注入。

然后第一个属于工具包，不导入也会报错，剩下五个属于spring的核心jar包。如果以后还需要spring的其他功能则再导入其他jar包。

目录结构：

3.spring入门Helloworld

首先肯定需要导入相关jar包，上面以述

首先需要配置spring的配置文件

<?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"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.2.xsd">
	<bean id="user" class="cn.spy.pojo.User"></bean>
</beans>

然后编写HelloWorld.java，有两种实现，一种是通过工厂方式创建对象，还有一种是直接创建对象。

public class HelloWorld {
       @Test
    public void testIOC1() throws Exception{
        Resource resource =new ClassPathResource("cn/spy/first/applicationContext.xml");
        @SuppressWarnings("deprecation")
        BeanFactory factory =new XmlBeanFactory(resource);
        User user =(User) factory.getBean("user");
        System.out.println(user.getId()+" : "+user.getUsername());
        
    }
    
    @Test
    public void testIOC2() throws Exception{
        ApplicationContext context= new ClassPathXmlApplicationContext("cn/spy/first/applicationContext.xml");
        System.out.println("-----容器创建完成-----");
        User user =(User) context.getBean("user");
        System.out.println(user.getId()+" : "+user.getUsername());
    }
}

public class User {

    private int id=1;
    private String username="张三";
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
}

分别测试两个方法，结果都为：

------------------------------------

细节：

<1>.创建对象分为单例和多例：需要在配置文件中直接scope属性来配置scope="singleton"为单例（就是默认值），在启动（容器初始化之前）就已经创建了bean，且整个应用只有一个。scope="prototype"是多例。它的创建则是在使用的时候才创建对象。

<2>.延迟创建：在配置文件中直接使用lazy-init属性来配置。lazy-init="false"就是不延迟创建对象，在系统启动的时候就创建对象，这个是默认值。 lazy-init="true"就是延迟初始化，在用到对象的时候才创建对象。（只对单例才会有效）。

<3>.创建对象后，方法的初始化和销毁：在配置文件中采用init-method属性进行配置，init-method="初始化执行方法"。这个方法在对象创建完之后执行。destroy-method="销毁执行方法"，在容器对象执行destory();销毁方法的时候执行。

4.spring创建对象

（1）调用无参数构造器创建对象（默认方式）

配置相关的配置文件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:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.2.xsd">
    <bean id="shopping1" class="cn.spy.pojo.Shopping"></bean>
</beans>

pojo：

public class Shopping {
	private String name;
	private String price;
	
	public Shopping() {
		super();
		// TODO Auto-generated constructor stub
		System.out.println("-----无参数构造器------");
	}
       @Override
    public String toString() {
        return "Shopping [name=" + name + ", price=" + price + "]";
    }
    
}

实现类：

public class CreateObj {

	@Test
	public void testIoc(){
		ClassPathXmlApplicationContext cpxac= new ClassPathXmlApplicationContext("cn/spy/first/applicationContext.xml");
		Shopping shopping =(Shopping) cpxac.getBean("shopping1");
		System.out.println(shopping);
	}
}

结果：

（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:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.2.xsd">
       <bean id="str" class="java.lang.String">
        <constructor-arg value="￥100"></constructor-arg>
    </bean>
    
    <bean id="shopping" class="cn.spy.pojo.Shopping">
        <constructor-arg value="黄金" index="0" type="java.lang.String"/>
        <constructor-arg index="1" type="java.lang.String" ref="str"/>
    </bean>
</beans>

构造方法第一个参数直接通过设置值得方式来传参，而第二个参数采用的是引用的方式，通过ref来实现的。

pojo：

public class Shopping {
	private String name;
	private String price;
    public Shopping(String name, String price) {
        System.out.println("---带参数构造器--------");
        this.name = name;
        this.price = price;
    }
       @Override
    public String toString() {
        return "Shopping [name=" + name + ", price=" + price + "]";
    }
    
}

实现：

public class CreateObj {

	@Test
	public void testIoc(){
		ClassPathXmlApplicationContext cpxac= new ClassPathXmlApplicationContext("cn/spy/first/applicationContext.xml");
		Shopping shopping =(Shopping) cpxac.getBean("shopping");
		System.out.println(shopping);
	}
}

结果：

（3）.工厂类使用静态方法创建对象

配置文件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:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.2.xsd">
        <bean id="shopping5" class="cn.spy.first.ObjFactory" factory-method="getStaticInstance"></bean> 
        <bean id="testFactory" class="cn.spy.pojo.Shopping"></bean>
</beans>

pojo：

public class Shopping {
	private String name;
	private String price;
	
	public Shopping() {
		super();
		// TODO Auto-generated constructor stub
		System.out.println("-----无参数构造器------");
	}

	public Shopping(String name, String price) {
		System.out.println("---带参数构造器--------");
		this.name = name;
		this.price = price;
	}

	@Override
	public String toString() {
		return "Shopping [name=" + name + ", price=" + price + "]";
	}
	
}

工厂类：

public class ObjFactory {
       // 静态方法创建对象
    public static Shopping getStaticInstance() {
        return new Shopping("工厂方式创建对象","调用静态方法");
    }
}

测试：

public class CreateObj {
       @Test
    public void testFactory(){
        ApplicationContext ac =new ClassPathXmlApplicationContext("cn/spy/first/applicationContext.xml");
        Shopping shopping =(Shopping) ac.getBean("shopping5");
        System.out.println(shopping);
    }
}

结果：

（4）.工厂类使用非静态方法创建对象

配置文件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:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.2.xsd">
        <bean id="factory" class="cn.spy.first.ObjFactory"></bean>
        <bean id="shopping4" factory-bean="factory" factory-method="getInstance"></bean> 
        <bean id="testFactory" class="cn.spy.pojo.Shopping"></bean>
</beans>

pojo：

public class Shopping {
	private String name;
	private String price;
	
	public Shopping() {
		super();
		// TODO Auto-generated constructor stub
		System.out.println("-----无参数构造器------");
	}

	public Shopping(String name, String price) {
		System.out.println("---带参数构造器--------");
		this.name = name;
		this.price = price;
	}

	@Override
	public String toString() {
		return "Shopping [name=" + name + ", price=" + price + "]";
	}
	
}

工厂类：

public class ObjFactory {
	// 实例方法创建对象
	public Shopping getInstance() {
		return new Shopping("工厂方式创建对象","调用实例方法");
	}
}

测试：

public class CreateObj {
       @Test
    public void testFactory(){
        ApplicationContext ac =new ClassPathXmlApplicationContext("cn/spy/first/applicationContext.xml");
        Shopping shopping =(Shopping) ac.getBean("shopping4");
        System.out.println(shopping);
    }
}

结果：

5.spring的核心--依赖注入

先简单说下，分层结构：db——》dao层（对数据库进行增删改查）——》service层（对dao层返回的结果进行业务逻辑处理）——》控制层（对系统请求进行页面跳转之类的控制，数据处理由service层提供）。

我这里只是模仿下，说下注入

（1）使用XML配置注入

dao层代码：

public class UserDaoImpl{

	public String getDbData(){
		System.out.println("对数据库操作");
		return "数据库操作结果";
	}
}

service层代码：

public class UserServiceImpl{
	
	private UserDaoImpl userDao;
	public void setUserDao(UserDaoImpl userDao) {
		this.userDao = userDao;
	}
	public void dealData(){
		String dbRs =userDao.getDbData();
		System.out.println(dbRs+"已经进行了逻辑处理");
	}
}

解释：这里我使用的是setter方式注入，经过上面的创建对象，可以猜想到也可以通过构造器注入的。

配置文件 bean.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"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.2.xsd">
	
	<bean id="userDaoRef" class="cn.spy.dao.UserDaoImpl"></bean>
	<bean id="userService" class="cn.spy.service.UserServiceImpl">
		<property name="userDao" ref="userDaoRef"></property>
	</bean>
	
</beans>

测试：

public class MyTest {
	
	@Test
	public void testDi(){
		ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
		UserServiceImpl userService =(UserServiceImpl) ac.getBean("userService");
		userService.dealData();
	}
}

结果：

（2）使用java注解来注入

dao层代码：

@Repository("userDao")
public class UserDaoImpl{

	public String getDbData(){
		System.out.println("对数据库操作");
		return "数据库操作结果";
	}
}

其实注解后面可以不用设置名字，但是如果以后存在多个dao，那么直接注入会让spring分不清，所以后面对应值，就给他提供了名字，以后其他的service可以通过名字注入此dao。

service层代码：

@Service("userService")
public class UserServiceImpl{
	@Autowired
	private UserDaoImpl userDao;
	
	public void dealData(){
		String dbRs =userDao.getDbData();
		System.out.println(dbRs+"已经进行了逻辑处理");
	}
}

配置文件 bean.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"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.2.xsd">
	<context:component-scan base-package="cn.spy.*"></context:component-scan>
</beans>

测试类：

public class MyTest {
	
	@Test
	public void testDi(){
		ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
		UserServiceImpl userService =ac.getBean(UserServiceImpl.class);
		userService.dealData();
	}
}

结果：

（3）使用 p 名称空间注入

简化了传统的注入的方式

dao层代码：

public class UserDaoImpl{

	public String getDbData(){
		System.out.println("对数据库操作");
		return "数据库操作结果";
	}
}

serivce层代码：

public class UserServiceImpl{
	
	private UserDaoImpl userDao;
	
	public void setUserDao(UserDaoImpl userDao) {
		this.userDao = userDao;
	}

	public void dealData(){
		String dbRs =userDao.getDbData();
		System.out.println(dbRs+"已经进行了逻辑处理");
	}
}

配置文件：

<?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"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.2.xsd">
	
	<bean id="userDao" class="cn.spy.dao.UserDaoImpl"></bean>
	<bean id="userService" class="cn.spy.service.UserServiceImpl" p:userDao-ref="userDao"></bean>
</beans>

测试：

public class MyTest {
	
	@Test
	public void testDi(){
		ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
		UserServiceImpl userService =ac.getBean("userService",UserServiceImpl.class);
		userService.dealData();
	}
}

结果：

-------------------------

6.java代码装配bean

其实对于在很多场景下通过组件扫描和自动装备实现spring的自动化配置是更为推荐的方式。但是呢，在某些时候自动化配置方案是行不通的，需要明确配置spring。譬如，你想使用第三方库中的组件装配到你的应用中，在这种情况下，是没有办法在它的类上添加@Component和@Autowired注解的，因此就不能使用自动化配置方案了。而需要采用显式配置方案，有两种，第一种xml方式在helloworld中已经介绍，第二种使用java代码装配bean在此处介绍。

还是前面的例子的改造：

dao层实现：

public class UserDaoImpl {
	public String getDbData(){  
        System.out.println("对数据库操作");  
        return "数据库操作结果";  
    }  
}

service层实现：

public class UserServiceImpl {
	private UserDaoImpl userDaoImpl;
	public void setUserDaoImpl(UserDaoImpl userDaoImpl) {
		this.userDaoImpl = userDaoImpl;
	}
	public void dealData(){  
        String dbRs =userDaoImpl.getDbData();  
        System.out.println(dbRs+"已经进行了逻辑处理"); 
    } 
}

配置类：

@Configuration
public class BeanConfig {//对于UserDaoImpl的java配置

	//注解可以指定bean名称，如果未指定，那么默认就是方法名，而此处就是userDaoImpl
	@Bean
	public UserDaoImpl userDaoImpl(){
		return new UserDaoImpl();
	}
	
	@Bean
	public UserServiceImpl userServiceImpl(){
		UserServiceImpl userServiceImpl =new UserServiceImpl();
		userServiceImpl.setUserDaoImpl(userDaoImpl());
		return userServiceImpl;
	}
}

测试类：

public class MyTest {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context =new AnnotationConfigApplicationContext(BeanConfig.class);
		UserServiceImpl userServiceImpl =context.getBean(UserServiceImpl.class);	
		userServiceImpl.dealData();
	}
}

结果：