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

一.新建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就是java对象  由spring来创建和管理 -->    
   
   <!-- id是bean的标识符 要唯一  如果没有配置id，name默认标识符 
   		如果配置id，又配置了name 那么name是别名
   		name可以设置多个别名 分隔符可以 是 空格 逗号 分号
   		class是bean的全限定名=包名+类名
   		如果不配置 id,和name 那么可以根据applicationContext.getBean(Class) 获取对象
   -->
   <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来创建对象的。

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

   总结：以前对象是由程序本身来创建，使用spring后，程序变为被动接收spring创建好的对象。  

   控制反转------依赖注入（dependency   injection）：通过Set方法注入的

IOC是一种·编程思想：由主动编程，变成被动接收

下一讲将详细讲解Spring框架IOC