Spring复习(一)

最新推荐文章于 2025-05-17 16:09:29 发布

原创最新推荐文章于 2025-05-17 16:09:29 发布 · 337 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Spring

Spring 专栏收录该内容

2 篇文章

订阅专栏

1.Spring一站式框架

①正是因为Spring框架性质是属于容器性质的。

②容器中装什么对象就有什么功能，所以可以一站式

③不仅不排斥其他框架，还能帮其他对象管理对象

④aop支持

⑤ioc思想

⑥spring jdbc

⑦aop事务

⑧junit测支持

2.Spring初体验：

Spring中最核心的四个包

3.关于spring的相关属性

①id和name属性

id :Bean 起个名字. 在约束中采用 ID 的约束:唯一.必须以字母开始，可以使用字母、数字、连字符、下划线、句话、冒号 id:不能出现特殊字符.

name:Bean 起个名字. 没有采用 ID 的约束. name:出现特殊字符.如果没有 id 的话 , name 可以当做 id 使用.

②scope 属性：Bean 的作用范围

singleton :默认值，单例的.

prototype :多例的

request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.

session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.

globalSession :WEB 项目中,应用在 Porlet 环境.如果没有 Porlet 环境那么 globalSession 相当

于 session.

4.Bean 的生命周期的配置:

通过配置标签上的 init-method 作为 Bean 的初始化的时候执行的方法，配置 destroy-method 作为 Bean 的销毁的时候执行的方法销毁方法想要执行，需要是单例创建的 Bean 而且在工厂关闭的时候，Bean 才会被销毁.

5.Spring 的 Bean 的管理 XML 的方式

① Spring 生成 Bean 的时候三种方式

无参数的构造方法的方式：

6.spring的一些野史

我这边分享一个spring整合的jar包，有需要的朋友可以下载下来用

链接：https://pan.baidu.com/s/1GHbu5q-tw8RQ8-hHtppVrw
提取码：x71x

spring的强大之处就是它将市场常用到的jar包都收集过来了并且做了一个整合，通用版4.2.4版

下面是解压之后的情况

单独说一下约束文件，以下是spring中常用的几个约束文件

下来就是spring中最基础用到的几个jar包：

还要导的一个常用的日志包

7.在Eclipse中导入Spring的约束文件

前提准备工作：

Window--》Preferences--》输入cata--》点击XML Catalog--》Add

准备添加第一个约束文件及spring-beans-4.2.xsd(从刚解压的那个spring整合包中找到约束文件里面添加即可)

导入一个spring-beans-4.2.xsd约束文件是这样，导入其他的也一样。。。

①首先它应该是在src底下，如果不知道以什么命名，就用applicationContext.xml这个吧

②进行配置

增加一个根元素（注意字母大小写）

③转换到设计模式

先Design--》Edit Namespaces

然后进去之后点Add--》钩xsi--》ok

出来之后应该是这样的，再继续Add

我这个beans-4.2是我之前添加好的，所以现在可以直接找到

这两部分保持一致

出现下面的这些就说明导入成功了

然后就变成这个样子了

再然后如果要测试是否成功，就是在beans标签底下按Alt+/如果有提示就说明成功了

8.新建一个User对象

9.把新建的对象配置到Spring的配置文件中

拿到对象的完整类名，然后配置到spring的bean中的class中

再继续name属性给它起个名字，为了以后取得时候好取，后面需要的时候可以直接根据名字取

10.测试在spring中已经配置好的对象

附上代码：

package com.yinxin.hello;

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

import com.yinxin.bean.User;

public class JunitDemo {
	@Test
	public void fun1(){
		
		//创建容器对象
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");//从类路径下加载spring的xml配置文件
		//向容器要“User”对象
		User user = (User) ac.getBean("user");
		//打印User对象
		System.out.println(user);
		
	}

}

11.spring的概念性问题：

IOC:Inverse of Control 反转控制

①将我们创建对象的方式反转了

②以前对象的创建是由我们开发人员自己维护，包括依赖关系也是自己注入

③使用了spring之后，对象的创建以及依赖关系可以由spring完成创建以及注入。

④反转控制就是反转了对象的创建方式，从我们自己创建反转给了程序（spring）。

DI：Dependency Injection 依赖注入，需要有IOC的环境，Spring创建这个类的过程中，Spring将类的依赖的属性设置进去。

①实现IOC思想需要 DI做支持

②注入方式：

set方法注入

构造方法注入

字段注入

③注入类型

值类型注入

引用类型注入

关于ApplicationContext&BeanFactory

BeanFactor接口：

spring原始接口，针对原始接口的实现类功能较为单一

BeanFactory接口实现类的容器，特点是每次在获得对象时才会创建对象

ApplicationContext接口:

每次容器启动时就会创建容器中配置的所有对象，并提供更多功能

从类路径下加载配置文件：ClassPathXmlApplicationContext

从硬盘绝对路径下加载配置文件：FileSystemXmlApplicationContext("D://xxxx//yyyy/xxxx")

总结： Web开发中，使用applicationapplicationContext,在资源匮乏的环境可以使用BeanFactory

12.Spring创建对象的方式：

①空参构造方式

②静态工厂（了解）

③实例化工厂（了解）

代码如下：

总体目录结构：

实体类：

package com.yinxin.bean;
/**
  *实体
  */
public class User {
  private String name; 
  private Integer age;
public User() {
	System.out.println("空参构造方法!");
}
public User(String name, Integer age) {
	super();
	this.name = name;
	this.age = age;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public Integer getAge() {
	return age;
}
public void setAge(Integer age) {
	this.age = age;
}


   

}

工厂类：

package com.yinxin.create;

import com.yinxin.bean.User;

/**
 * @content 工厂类
 * @author syp
 * @time 2019年6月25日09:59:54
 */

public class UserFactory {
 
	public static User createUser(){
		System.out.println("静态工厂创建User"); 	
		return new User();
	}
	
	public User createUser2(){
		System.out.println("实例工厂创建User");
		return new User();
	}
}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">
<!-- 将User对象交给spring容器管理 ,即class：放置完整类名，name：给它起个名字	-->
<!-- 创建方式1：空参构造创建 -->
<bean name="user" class="com.yinxin.bean.User"></bean>
<!-- 创建方式2：静态工厂创建 
  调用UserFactory的createUser方法创建名为user2的对象，放进容器
 -->
 <bean name="user2" class="com.yinxin.create.UserFactory" factory-method="createUser"></bean> 
 <!-- 创建方式3：实例工厂创建 
  调用UserFactory对象的createUser2方法创建名为user3的对象，放入容器
 -->
 <bean name="user3" factory-bean="userFactory" factory-method="createUser2"></bean> 
 <bean name="userFactory" class="com.yinxin.create.UserFactory" ></bean> 
</beans>

测试类：

package com.yinxin.hello;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.yinxin.bean.User;
/**
 * @content 测试类
 * @author syp
 * @time 2019年6月25日11:09:26
 */

public class JunitDemo {
	//创建方式1：空参构造方法
	@Test
	public void fun1(){
		//创建容器对象
		ApplicationContext ac=new ClassPathXmlApplicationContext("com/yinxin/create/applicationContext.xml");//从类路径下加载spring的xml配置文件
		//向容器要“User”对象
		User u = (User) ac.getBean("user");
		//打印User对象
		System.out.println(u);
		
	}
	//创建方式2：静态工厂
	@Test
	public void fun2(){
		//创建容器对象
		ApplicationContext ac=new ClassPathXmlApplicationContext("com/yinxin/create/applicationContext.xml");//从类路径下加载spring的xml配置文件
		//向容器要“User”对象
		User u = (User) ac.getBean("user2");
		//打印User对象
		System.out.println(u);
	}
	//创建方式2：实例工厂
	@Test
	public void fun3(){
		
		//创建容器对象
		ApplicationContext ac=new ClassPathXmlApplicationContext("com/yinxin/create/applicationContext.xml");//从类路径下加载spring的xml配置文件
		//向容器要“User”对象
		User u = (User) ac.getBean("user3");
		//打印User对象
		System.out.println(u);
	}


}

测试类运行结果：

13.关于Spring中Bean元素进阶的scope属性

①singleton（默认值）：单例对象.被标识为单例对象在spring容器中只会存在一个对象

创建多个对象后看下测试结果：

②prototype 多例原型，被标识为多例的对象，每次再获得才会创建，每次创建都是新的对象

及用法和上面的单例对象正好相反，它所创建的多个对象都是新的，即它们都指向不同的地址

设立多例对象后运行的效果：

③request（了解）：Web环境下，对象与request生命周期一致

④session（了解）：Web环境下，对象与session生命周期一致

总结：

当Struts2和Spring整合的时候，action要交给Spring来管理，这样的话Struts2每次调用action或者访问action的时候都会找Spring要，这个时候切记，action要配置成多例模式，因为action在Struts2从架构上来说，是每次请求都会创建一个新的action,所以action的这个bean在使用的时候必须设置为多例的。如果为单例的就完了，假如同时有10个请求过来，Struts2找Spring要action,结果Spring给了10个请求统一的action,这样就改变了struts2的设计了，那么问题就多了。

14.关于Spring中Bean元素进阶的生命周期

①配置一个方法作为生命周期初始化方法，Spring会在对象创建之后立即调用。

init-method

②配置一个方法作为生命周期的销毁方法,Spring容器在关闭并销毁容器中的对象之前调用。

destory-method

图示：

配置文件：

实体类中加：

在测试类中加：

测试运行结果：

15.关于Spring的分模块配置

在一个主配置文件中引入其他配置文件

16.Spring的Bean的属性注入：

①set方法注入

测试类运行效果：

测试类运行结果：

②构造函数注入

测试类运行结果：

③P名称空间注入（了解）

④spel注入（了解）

注：引用类型是不能用Spel表达式的；

⑤复杂类型注入

实体类：

package com.yinxin.inject;

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

public class CollectionBean {
	private Object[] obj;  //数组类型注入
	private List list;   //list类型注入
	private Map map;    //map类型注入
    private Properties prop; //配置文件类型注入
	public CollectionBean() {
		super();
		// TODO Auto-generated constructor stub
	}
	public CollectionBean(Object[] obj, List list, Map map, Properties prop) {
		super();
		this.obj = obj;
		this.list = list;
		this.map = map;
		this.prop = prop;
	}
	public Object[] getObj() {
		return obj;
	}
	public void setObj(Object[] obj) {
		this.obj = obj;
	}
	public List getList() {
		return list;
	}
	public void setList(List list) {
		this.list = list;
	}
	public Map getMap() {
		return map;
	}
	public void setMap(Map map) {
		this.map = map;
	}
	public Properties getProp() {
		return prop;
	}
	public void setProp(Properties prop) {
		this.prop = prop;
	}
	@Override
	public String toString() {
		return "CollectionBean [obj=" + Arrays.toString(obj) + ", list=" + list + ", map=" + map + ", prop=" + prop
				+ "]";
	}
    
    
}

配置文件