Spring学习日志（1）

Spring框架的IOC开发的两种模式，包括XML开发与注解开发的比较

Spring的简介

什么是Spring

Spring是一个开源框架，于2003年兴起的轻量级java开发框架，简单而言，Spring是一个分层的JAVASE/EEfull-stack（一站式）开源框架

Spring入门（IOC）

一、什么是IOC

• IOC（Inversion of Control）：控制反转。
  
  控制反转：将对象的控制权反转交给Spring

• 导包 (官网：http://SPring.io/)
  
• 引入约束文件

在spring的解压路径下spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

• Spring底层实现原理：
  
• Spring学习路线
  
• 把类交给Spring处理，有两种方式

1 . 通过XML配置方式

package Spring.demo1;
/**
 * 业务管理层的接口
 * @author rong
 *
 */
public interface UserService {
 public void add();
}

package Spring.demo1;
/**
 * 业务管理层的实现类
 * @author rong
 *
 */
public class UserServiceImp implements UserService {
	private String name;

	public void setName(String name) {
		this.name = name;
	}
	@Override
	public void add() {
		// TODO Auto-generated method stub
		System.out.println("UserServiceImp被执行了"+name);
	}
}

package Spring.demo1;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Test {
	@org.junit.Test
	public void demo1(){
//		UserService user=new UserServiceImp();
		UserServiceImp user=new UserServiceImp();
		user.setName("张三");
		user.add();
	}
	/**
	 * Spring 方式的调用
	 */
	@org.junit.Test
	public void demo2(){
		/**
		 * 创建Spring工厂
		 */
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("application.xml");
		UserService User = (UserService) applicationContext.getBean("UserService");
		User.add();
	}
	@org.junit.Test
	public void demo3(){
		/**
		 * 加载磁盘上的配置文件
		 */
		ApplicationContext applicationContext=new FileSystemXmlApplicationContext("D:\\111\\application.xml");
		UserService user = (UserService) applicationContext.getBean("UserService");
		user.add();
	}
}

XML配置文件

其中包括了属性的注入（通过构造函数或Set方法）
SPEL的/font>的注入
集合的注入的注入

	
	
		
	
	
	
	
	
	
	
	    
	    
	
	
	
	
	

	
	

	
	
	
	
	
	
		
		
	

	
	
	
		
			
				1
				2
				3
			
		
	
		
			
				张三
				李四
				王五
			
		
	
		
			
				张三
				李四
				王五
			
		
	
		
			
		
	

2 . 通过注解方式

• 导包
  
  除了引入基本的开发包，还需要引入AOP包
  
• 引入约束文件
  
  哪里找？
  spring-framework-4.2.4.RELEASE-docs\spring-framework-reference\html中找xsd-configuration.html中找到Context约束（其中包含了beans约束，beans约束是Spring中最基本的约束）
  
• 开启组件扫描(在XML文件中)

编写测试类

package demo1;

public interface UserDao {
	public void sava();
}

package demo1;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component(value="UserDaoImp")//相当于
public class UserDaoImp implements UserDao {
	@Value("张三")
	private String name;
	//可以不提供set方法，则需要将属性的注解添加到属性上；若有set方法，则需要将属性的注入添加到set方法上
	/*@Value("张三")
	public void setName(String name) {
		this.name = name;
	}
*/
	@Override
	public void sava() {
		// TODO Auto-generated method stub
		System.out.println("sava()方法执行了。。");
	}

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

说明：属性注入的注解分为以下类型

1. 普通类型
   
   @value（“”）设置普通属性的值
2. 对象类型
   
   @Autowired：设置对象的属性的值。
   
   注意：按照类型完成属性注入，而不是名称，与Component（“CLassName”）无关
   
   一般我们习惯按名称匹配
   
   下面两个同时写

@Autowired
@Qualifier(value=”ClassName”) //强制使它按照名称的属性注入
@Resource(name=”ClassName”)：完成对象属性的注入，等价于上面连续两个(开发中常用)

Bean的其他注解

package demo2;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component(value="custom")//
@Scope("prototype")
public class custom {
	@PostConstruct//初始化注解，相当于nit-method="init"
	public void init(){
		System.out.println("初始化方法执行了");
	}
	public void save(){
		System.out.println("save方法执行了");
	}
	@PreDestroy//destory注解，相当于destory-method="destory"
	public void destory(){
		System.out.println("destory方法执行了");
	}
}

说明：

1. 生命周期相关的注解

@PostConstruct：初始化方法
@PreDestory：销毁方法
2. Bean的作用范围注解(重要)

@Scope( “ ”) ：作用范围

• Prototype : 多例
• Request :
• Session:
• Globalsession:
  测试案例：

package demo2;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	@org.junit.Test
	public void test1(){
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
		custom c = (custom) applicationContext.getBean("custom");
		System.out.println(c);
		custom c2 = (custom) applicationContext.getBean("custom");
		System.out.println(c2);
	}
}

输出结果：

初始化方法执行了
demo2.custom@1d9d4b
初始化方法执行了
demo2.custom@1227d8d

说明：由于使用了@Scope(“prototype”)，多例模式初始化了两次，得到两个不同的id；

3 . 两种方式的比较

• 适用场景
  • XML：可以使用任何场景
    • 结构清晰，维护方便
  • 注解：必须修改源代码（如果你无法修改源代码，只能用XML）
    • 开发方便，速度快

4 . XML与注解的整合开发

思路：用XML用来管理类的注入，用注解完成属性的注入。
测试案例：

package Demo3;
import org.springframework.stereotype.Component;
//@Component("order")
public class order {
	public void play()
	{
		System.out.println("生产产品");
	}
}

package Demo3;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
//@Component("orderService")//相当于
public class orderService {
	@Resource(name="order")//这个name就是配置文件(applicationContext.xml)里面的或者
	//如果是用的类上注解等同于@Component(value=”id/name”)中的id
	private order od;
	public orderService() {
		System.out.println("无参构造方法被调用...");
		// TODO Auto-generated constructor stub
	}
	public void t(){
		od.play();
	}
}

package Demo3;
import javax.annotation.Resource;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test {
	@Resource(name="orderService")
	private orderService se;
	@org.junit.Test
	public void test1(){
		se.t();
	}
}

配置文件