Spring框架知识点（一）

Spring是一站式框架

1.spring在JavaEE三层结构中，每一层都提供不同的解决技术
Web 层：springMVC
Service 层：spring 的 ioc
Dao 层：spring 的 jdbcTemplate

Spring 概念

1. spring 是开源的轻量级框架
2. spring 核心主要两部分：
（1）Aop：面向切面编程，扩展功能不是修改源代码实现
（2）Ioc ：控制反转
— 比如有一个类，在类里面有方法（不是静态的方法），调用类里面的方法，创建类的对象，使用对象调用方法，创建类对象的过程，需要new出来对象。
— 把对象的创建不是通过new的方式实现，而是交给 spring 配置创建类对象

Ioc 底层原理

1. ioc底层原理使用技术
（1）xml配置文件
（2）dom4j解析xml
//根据配置文件的id值，得到id值对应的class属性值
String classValue = “class属性值”;
（3）工厂设计模式
（4）反射创建类的对象
反射的关键代码：
Class clazz = Class.forName(classValue); //使用发射创建类对象
UserService service = clazz.newInstance(); //创建类对象
如下图所示：

Spring的Bean 管理（xml方式）

Bean实例化的方式

1.在spring 里面通过配置文件创建对象
2.Bean实例化三种实现方式
第一种 使用类的无参构造创建（重点）

类里面没有无参数的构造，会出现异常。
第二种 使用静态工厂创建
（1）创建静态的方法，返回类对象

---

// 加载配置文件，根据创建对象
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       //得到配置创建的对象
		Bean2 bean2= (Bean2) context.getBean("bean2");
		System.out.println(bean2);

---

输出结果：com.itcast.bean.Bean2@2833cc44

第三种 使用实例化工厂创建
（1）创建不是静态的方法，返回类的对象
Bean标签常用属性
（1）id 属性：起的名称，id属性值名称任意命名。
— Id属性值，不能包含特殊符号
— 根据id值得到配置对象
（2）class属性：创建对象所在类的全路径
（3）Name属性：功能和id属性一样的，id属性值不能包含特殊符号，但是name属性可以包含特殊字符。
（4）Scope属性：bean的作用范围
—singleton: 默认值，单例

—prototype: 多实例的对象

// 加载配置文件，根据创建对象
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 得到配置创建的对象
		User user = (User) context.getBean("user");
		User user1 = (User) context.getBean("user");
		System.out.println(user);
		System.out.println(user1);

结果：

com.itcast.ioc.User@5bc79255
com.itcast.ioc.User@47ef968d

— request: 创建对象把对象放到request
— session: 创建对象把对象放到session
— globalSession: 创建对象把对象放到globalSession（全局性的）—》登陆中

属性注入方式介绍

1.创建对象的时候，向类里面属性里面设置值
2.属性注入的方式（三种方式）
第一种 使用set方法注入

Public class User{
  Private String name;
 Public void setName(String name){
   This.name = name;
  }
}
User user = new User();
User.setName(“abcd”);

第二种 有参数构造注入

Public class User{
  Private String name;
 Public User(String name){
   This.name = name;
  }
}
User user = new User(“lucy”);

第三种 使用接口注入

Public interface Dao{
  Public void delete(String name):
}
Public class DaoImpl implements Dao{
  Private String name;
 Public void delete(String name){
  This.name=name;
  }
}

3.在spring框架里面，支持前面两种方式
（1）set方法注入（重点）

public class Book {
	private String bookName;

	//set方法
	public void setBookName(String bookName) {
		this.bookName = bookName;
	}

	public void demobook() {
		System.out.println("book..........." + bookName);
	}
}

---

（2）有参数构造注入

public class PropertyDemo1 {
	private String userName;

	public PropertyDemo1(String userName) {
		this.userName = userName;
	}

	public void test1() {
		System.out.println("demo1............" + userName);
	}
}

---

注入对象类型属性（重点）

1.创建service类和dao类

package com.itcast.ioc;

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

（1）在service得到dao对象

package com.itcast.ioc;

public class UserService {
	// 1定义dao类型属性
	private UserDao userDao;

	// 2生成set方法
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	public void add() {
		System.out.println("service......");
	   //在service里面得到dao类对象，才能调用dao里面的方法
		/*UserDao dao=new UserDao();
		dao.add();*/
		userDao.test();
	}
}

2.具体实现过程：
（1）在service里面把dao作为类型属性
（2）生成dao类型属性的set方法

public class UserService {
	// 1定义dao类型属性
	private UserDao userDao;

	// 2生成set方法
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

（3）在配置文件中完成对象类型属性值注入

（4）测试

@Test
	public void test5() {
		// 加载配置文件，根据创建对象
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 得到配置创建的对象
	    UserService userService=(UserService) context.getBean("userService");
	    userService.add();
	}

结果：

P名称空间注入

配置文件头部需要加入空间配置：

 xmlns:p="http://www.springframework.org/schema/p"

具体实现过程：
1.Person.java类

package com.itcast.property;

public class Person {
	private String pname;

	public void setPname(String pname) {
		this.pname = pname;
	}

	public void test1() {
		System.out.println("person..." + pname);
	}
}

2.配置文件：

3.测试：

@Test
	public void test6() {
		// 加载配置文件，根据创建对象
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 得到配置创建的对象
		Person person = (Person) context.getBean("person");
		person.test1();
	}

结果：person...lucy

注入复杂类型属性

实例：
TestEntity.java

package com.itcast.entity;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import com.itcast.ioc.User;

public class TestEntity {
	private String specialCharacter1; // 特殊字符1
	private String specialCharacter2; // 特殊字符2
	private User innerBean; // javaBean 类型
	private List list; // List类型
	private String[] array; // 数组类型
	private Set set; // set类型
	private Map map; // map类型
	private Properties props; // peoperties 类型
	private String emptyValue; // 注入空字符串值
	private String nullValue = "init value"; // 注入null值

	public String getSpecialCharacter1() {
		return specialCharacter1;
	}

	public void setSpecialCharacter1(String specialCharacter1) {
		this.specialCharacter1 = specialCharacter1;
	}

	public String getSpecialCharacter2() {
		return specialCharacter2;
	}

	public void setSpecialCharacter2(String specialCharacter2) {
		this.specialCharacter2 = specialCharacter2;
	}

	public User getInnerBean() {
		return innerBean;
	}

	public void setInnerBean(User innerBean) {
		this.innerBean = innerBean;
	}

	public List getList() {
		return list;
	}

	public void setList(List list) {
		this.list = list;
	}

	public String[] getArray() {
		return array;
	}

	public void setArray(String[] array) {
		this.array = array;
	}

	public Set getSet() {
		return set;
	}

	public void setSet(Set set) {
		this.set = set;
	}

	public Map getMap() {
		return map;
	}

	public void setMap(Map map) {
		this.map = map;
	}

	public Properties getProps() {
		return props;
	}

	public void setProps(Properties props) {
		this.props = props;
	}

	public String getEmptyValue() {
		return emptyValue;
	}

	public void setEmptyValue(String emptyValue) {
		this.emptyValue = emptyValue;
	}

	public String getNullValue() {
		return nullValue;
	}

	public void setNullValue(String nullValue) {
		this.nullValue = nullValue;
	}

}
User.java
package com.itcast.ioc;

public class User {
	private String username;

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}
}

配置文件：

    
        
            
            
        
        
            P&G>
        
        
        
            
                
                    扎根三
                
            
        
        
        
            
                足球
                篮球
            
        
        
        
            
                足球
                篮球
            
        
        
        
            
                华硕
                联想
            
        
        
        
            
        
        
            
                
                足球
                篮球
            
        
        
        
        
        
   

测试：

@Test
	public void test7() {
		// 加载配置文件，根据创建对象
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 得到配置创建的对象
		TestEntity testEntity = (TestEntity) context.getBean("testEntity");
		System.out.println(" 特殊字符1：" + testEntity.getSpecialCharacter1());
		System.out.println(" 特殊字符2：" + testEntity.getSpecialCharacter2());
		System.out.println("javaBean 类型 姓名：" + testEntity.getInnerBean().getUsername());
		System.out.println("List类型：" + testEntity.getList());
		System.out.println("数组类型：" + testEntity.getArray()[0] + "\t" + testEntity.getArray()[1]);
		System.out.println("set类型：" + testEntity.getSet());
		System.out.println("map类型：" + testEntity.getMap());
		System.out.println("peoperties 类型：" + testEntity.getProps());
		System.out.println("注入空字符串值：[" + testEntity.getEmptyValue() + "]");
		System.out.println("注入null值：" + testEntity.getNullValue());
	}

结果：

特殊字符1：P&G
 特殊字符2：P&G>
javaBean 类型 姓名：扎根三
List类型：[足球, 篮球]
数组类型：足球	篮球
set类型：[华硕, 联想]
map类型：{football=足球, basketball=篮球}
peoperties 类型：{football=足球, basketball=篮球}
注入空字符串值：[]
注入null值：null

IOC 与 DI 的区别

（1）IOC ：控制反转，把对象创建交给spring进行配置
（2）DI ：依赖注入，向类里面的属性中设置值
（3）关系：依赖注入不能单独存在，需要在ioc基础上完成操作
Spring整合web项目原理
1.加载spring核心配置文件

// 加载配置文件，根据创建对象
ApplicationContext context = 
new ClassPathXmlApplicationContext("applicationContext.xml");

（1）new 对象，功能可以实现，效率很低
2.实现思想：把加载配置文件和创建对象过程，在服务器启动时候完成。
3.底层实现原理：
（1）ServletContext对象
（2）监听器
（3）具体使用：
— 在服务器启动的时候，为每个项目创建一个ServletContext对象；
— 在ServletContext对象创建的时候，使用监听器可以具体到ServletContext对象在什么时候创建；
— 使用监听器监听到ServletContext对象创建时候，
— 加载spring配置文件，把配置文件配置对象创建；
— 把创建出来的对象放到ServletContext域对象里面（setAttribute方法）；
— 获取对象时候，到ServletContext域得到（getAttribute方法）