了解spring框架（第一篇）

框架简介

spring是2003年兴起的一个开源的、轻量级的框架，框架的主要优势之一就是分层结构，同时为J2EE应用程序开发提供集成的框架。spring用基本的JavaBean来完成以前只能由EJB完成的事情。spring的核心是控制反转（IOC）和面向切面（AOP）。

JavaEE开发分层结构

spring在JavaEE三层架构中的每一层都有不同的解决技术：
WEB层：springMVC
service层：Bean管理（IOC）
持久层：JdbcTemplate模板

IOC的原理实现

IOC——控制反转，用到了工厂设计模式+反射+配置文件（或者注解方式）
（1）之前创建对象的时候，都是通过类名new出来的。
（2）IOC创建对象的时候，先通过配置文件配置要创建对象的类。然后会通过dom4j解析xml文件，再使用反射创建类对象。
其实，IOC——Inversion of Control——控制反转——指的是对象的创建权反转(交给)给 Spring。作用是实现了程序的解耦合.

IOC和DI

IOC :控制反转,将对象的创建权交给了 Spring。
DI :Dependency Injection 依赖注入.需要有 IOC 的环境,Spring 创建这个类的过程中,Spring 将类的依赖的属性设置进去。

spring案例

步骤一：导入jar包。
官网：http://spring.io/ 下 载 地 址 ： http://repo.springsource.org/libs-release-local/org/springframework/spring
也可以通过我分享的百度云链接直接下载spring的最全jar包：链接地址https://pan.baidu.com/s/172ZQYoYTObvKvdxqfQ6eCA
步骤二：创建实体类，并在类里面创建方法

public class User {
	public void show() {
		System.out.println("show......");
	}
}

步骤三：创建spring配置文件
（1）spring的配置文件的名称和位置不是固定的。
（2）需要引入schema约束。

<?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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!-- 配置对象的创建 -->
	<bean id="user" class= "User类的全路径"></bean>
</beans>

步骤四：测试类

public class TestIOC {
	@Test
	public void testUser() {
		//加载spring配置文件，根据配置文件创建对象
		ApplicationContext context = new ClassPathXmlApplicationContext("配置文件名");
		//得到配置文件创建的对象
		User user = (User)context.getBean("user");
		user.show();
		}
}

运行结果：

**注解：**在测试类中，通过第一行代码加载配置文件，getBean方法里面的参数是配置文件中bean标签的id值，这样就会根据配置文件创建user对象。调用User类里面的方法，打印出结果。整个代码中没有通过new来创建对象，而是通过配置文件去创建，底层执行的是反射。

属性注入介绍

属性注入就是在创建对象的时候给类里面的属性设置值。一共有两种方法，分别是有参构造和set方法。

有参构造注入属性

（1）创建实体类

public class PropertyDemo {
	private String username;

	public PropertyDemo(String username) {
		this.username = username;
	}
	
	public void test() {
		System.out.println("test..."+username);
	}
}

（2）完成配置文件

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- 使用有参数构造注入属性 -->
	<bean id="propertyDemo" class="PropertyDemo类的全路径">
		<constructor-arg name="username" value="小王"></constructor-arg>
	</bean>
		
</beans>

（3）测试

public class TestIOC {
	@Test
	public void testUser() {
		// 加载spring配置文件，根据配置文件创建对象
		ApplicationContext context = new ClassPathXmlApplicationContext("配置文件名");
		 //得到配置文件创建的对象
		PropertyDemo propertyDemo = (PropertyDemo) context.getBean("propertyDemo");
		propertyDemo.test();
	}
}

运行结果：

注解
（1）使用标签constructor-arg
（2）name属性的值是类里面待注入的属性的名称

set注入属性

（1）创建实体类

public class Book {
	private String bookName;

	public void setBookName(String bookName) {
		this.bookName = bookName;
	}

	public void add() {
		System.out.println("使用set方法注入：" + bookName);
	}
}

（2）完成配置文件

public class Book {
	private String bookName;

	public void setBookName(String bookName) {
		this.bookName = bookName;
	}

	public void add() {
		System.out.println("使用set方法注入：" + bookName);
	}
}

（2）完成配置文件

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!-- 使用set方法注入属性 -->
	<bean id="book" class="Book类全路径">
		<property name="bookName" value="海澜之家"></property>
	</bean>
</beans>

（3）测试

public class TestIOC {
	@Test
	public void testUser() {
		ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
		Book book1 = (Book) context.getBean("book");
		book1.add();
		}
	}
		

运行结果：

注解：
（1）使用标签property。
（2）属性name的值是需要注入的属性名称。

使用对象类型的属性

（1）创建两个类，service类和dao类，并在service类中得到dao对象。

public class UserDao {
	public void add() {
		System.out.println("dao...");
	}
}

public class UserService {
	private UserDao userDao;

	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	
	public void add() {
		System.out.println("service...");
		userDao.add();
	}
}

（2）完成配置文件

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!-- 注入对象类型属性 -->
	<bean id="serviceID" class="cn.itcast.ioc.UserService">
		<property name="userDao" ref="daoID"></property>
	</bean>
	<bean id="daoID" class="cn.itcast.ioc.UserDao"></bean>
</beans>

（3）测试

public class TestIOC {
	@Test
	public void testUser() {
		ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
		UserService userService = (UserService) context.getBean("serviceID");
		userService.add();
	}
}

运行结果：

注解：
（1）和set方法注入属性类似，只不过这里是注入对象类型的属性。
（2）要在配置文件创建两个对象，并将其中之一注入到另一个对象里。
（3）使用property标签，name属性的值是待注入的对象名称，ref是待注入的对象的id值。

spring的注解方式

步骤一：引入jar包，注意要有AOP的jar包（前面有链接）。
步骤二：创建实体类，并在类里面创建方法。
步骤三：创建spring配置文件，引入约束。（这里会引入context约束）
步骤四：在配置文件中开启注解扫描。

<?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"> <!-- bean definitions here -->

	<!-- 开启注解扫描 到包里面扫描类、方法、属性上面是否有注解 -->
	<context:component-scan base-package="包名"></context:component-scan>

	<!-- 只会扫描属性上面的注解 -->
	<context:annotation-config></context:annotation-config>
</beans>

注解方式创建对象

（1）创建类，并在类上写上注解

@Component(value="user")  //相当于<bean id="user" class="全路径"/>
public class User {
	public void show() {
		System.out.println("show......");
	}
}

(2)配置文件

	<!-- 开启注解扫描 到包里面扫描类、方法、属性上面是否有注解 -->
	<context:component-scan base-package="包名"></context:component-scan>

(3)写测试类进行测试

public class TestAnnotation {
	@Test
	public void testUser() {
		ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
		User user1 = (User) context.getBean("user");
		user1.add();
	}
}

运行结果：

注解方式注入属性

（1）第一步：创建UserService类和UserDao类，并用注解的方式分别得到对象，
在UserService类中注入UseDao的对象。

@Component(value="userdao")
public class UserDao {
	public void addDao() {
		System.out.println("userDao......");
	}
}

@Service(value="userservice")
public class UserService {
	@Resource(name="userdao")
	private UserDao userDao;
	
	public void addService() {
		System.out.println("userService......");
		userDao.addDao();
	}
}

（2）配置文件

	<!-- 开启注解扫描 到包里面扫描类、方法、属性上面是否有注解 -->
	<context:component-scan base-package="包名"></context:component-scan>

（3）写测试类进行测试

public class TestAnnotation {
	@Test
	public void testUser2() {
		ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
		UserService userService = (UserService) context.getBean("userservice");
		userService.addService();
	}
}

运行结果：

注
（1）Spring 中提供@Component 的三个衍生注解:(功能目前来讲是一致的)
* @Controller :WEB 层
* @Service :业务层
* @Repository :持久层
这三个注解是为了让标注类本身的用途清晰，Spring 在后续版本会对其增强。
（2）使用属性注解注入的方式，可以不用手动提供set方法。
（3）@Value :用于注入普通类型。
@Autowired :自动装配: * 默认按类型进行装配。
* 按名称注入: * @Qualifier:强制使用名称注入。

• @Resource 相当于: * @Autowired 和@Qualifier 一起使用。
  一般情况下，创建对象使用配置文件方式，注入属性使用注解方式。

后续会讲spring的AOP操作。。。