二.Spring4学习-----了解IOC （控制反转）

深藏阁楼爱情的钟 2022-06-07 03:58 183阅读 0赞

# 一.新建Java项目spring4\_ioc1 #

## 1.新建Dao层 ##

public interface UserDao { public void getUser(); }

## 2.新建Dao层的实现层 ##

UserDaoMysqlImpl.java

public class UserDaoMySqlImpl implements UserDao{
    	@Override
    	public void getUser() {
    		System.out.println("mysql获取用户数据");
    	}
    }

UserDaoOracleImpl.java

public class UserDaoOracleImpl implements UserDao{
    	@Override
    	public void getUser() {
    		System.out.println("oracle获取用户数据");
    	}
    }

## 3.service层 ##

public interface UserService {
    	public void getUser();
    }

## 4.service实现层 ##

（一）传统的方式

public class UserServiceImpl implements UserService{
    	
    	//此处需要使用Mysql就使用Mysql，需要Oracle就使用Oracle
    	private UserDao userDaoMySqlImpl=new UserDaoMySqlImpl();
    	
    	@Override
    	public void getUser() {
    		userDaoMySqlImpl.getUser();
    	}
    }

（二）将Dao层抽取出来的方式，需要什么就注入什么Dao

public class UserServiceImpl implements UserService{
    	private UserDao userDao=null;
    	public void setUserDao(UserDao userDao) { this.userDao = userDao; }
    	@Override
    	public void getUser() {
    		userDao.getUser();
    	}
    }

## 5.测试 ##

（一）对传统方式的测试

public class Test {
    	public static void main(String[] args) {
    		UserServiceImpl userService = new UserServiceImpl();
    		userService.getUser();
    	}
    }

测试结果：mysql获取用户数据

（二）对Service注入不同的Dao的方式

public class Test {
    	public static void main(String[] args) {
    		UserServiceImpl userService = new UserServiceImpl();
    		userService.setUserDao(new UserDaoMySqlImpl());
    		userService.getUser();
    		System.out.println("---------------");
    		userService.setUserDao(new UserDaoOracleImpl());
    		userService.getUser();
    	}
    }

测试结果：

mysql获取用户数据  
\---------------  
oracle获取用户数据

## 6.结果对比第二种相对第一种    ##

**a.对象由原来程序本身创建，变为了程序接收对象。**

**b.程序员主要精力集中于业务实现**

**c.实现了service和dao的解耦工作。Service和dao实现了分离。没有直接依赖关系。**

**d.如果dao的实现发生改变，应用程序本身不用改变。**

第二种的思想便是控制反转的思想。下面我面来写第一个HelloSring

# 二.HelloSpring #

## 1.新建spring4\_hello ##

### 1)导入jar包 ###

commons-logging-1.1.1.jar

spring-aop-4.1.6.RELEASE.jar

spring-aspects-4.1.6.RELEASE.jar

spring-beans-4.1.6.RELEASE.jar

spring-context-4.1.6.RELEASE.jar

spring-context-support-4.1.6.RELEASE.jar

spring-core-4.1.6.RELEASE.jar

spring-expression-4.1.6.RELEASE.jar

spring-jdbc-4.1.6.RELEASE.jar

spring-orm-4.1.6.RELEASE.jar

spring-tx-4.1.6.RELEASE.jar

spring-web-4.1.6.RELEASE.jar

spring-webmvc-4.1.6.RELEASE.jar

### 2）编写Hello.java ###

public class Hello {
    	public Hello() {
    		System.out.println("hello 被创建");
    	}
    	private String name;
    	private boolean sex;
    	
    	public boolean isSex() {
    		return sex;
    	}
    	public void setSex(boolean sex) {
    		this.sex = sex;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public void show(){
    		System.out.println("hello,"+name);
    	}
    }

### 3）编写Spring配置文件 ###

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="h1" name="hello h2,h3;h4" class="cn.sxt.bean.Hello">
       	<property name="name" value="张三"/>
       </bean>
    </beans>

### 4)编写Test.java ###

public class Test {
    	public static void main(String[] args) {
    		//1.创建Spring的IOC容器，解析beans.xml文件 生成管理相应的bean对象
    		BeanFactory context = new ClassPathXmlApplicationContext("beans.xml");
    		//Hello hello = (Hello)context.getBean("h4");
                    //2.从容器中获取Bean
                   Hello hello= context.getBean(Hello.class);
                    //3.调用方法
                   hello.show();
    	}
    }

测试结果：

hello 被创建  
hello,张三

### 5）.思考 ###

a)Hello对象是谁创建的？

**Hello对象是Spring容器创建的**

Hello hello= context.getBean(Hello.class);

b)Hello对象属性是怎么设置的？

**   Hello对象属性是由spring容器来设置的。**

**结论：**

**   这个过程就叫做控制反转。**

**   控制的内容：指谁来控制对象的创建：传统的应用程序对象的创建由程序本身控制的。使用spring后，是由spring来创建对象的。**

**   反转：正传指程序来创建对象。反转指程序本身不去创建对象，而变为被动接受的对象。**