Spring框架核心技术--IOC容器
Spring框架核心技术–IOC容器
-
-
- Spring框架核心技术IOC容器
- 概述
- Spring框架
- 专业术语详解
- Spring框架六大模块功能
- Spring开发步骤
- bean对象创建的细节
- SpringIOC容器
- 对象依赖关系
- Spring框架核心技术IOC容器
-
概述
简单来说Spring就是处理对象的创建、以及对象的依赖关系，之前的解决方案我们都是采用entity、dao、service、servlet、Jsp分开写，并且注意这些包之间的依赖关系，现在的Spring框架使得这件事情变得十分的简单，这是功能最强大的一个框架。Spring框架主页:www.springsource.org 。
Spring框架
Spring框架，可以解决对象创建以及对象之间的依赖关系的一种框架，且可以和其它框架一起使用，包括Spring和Struts、Spring和Hibernate框架的整合，总的来说，Spring框架是一个起到整合(粘合)作用的框架。
专业术语详解
组件/框架设计
- 侵入式设计
引入了框架，对现有的类的结构有影响，即需要实现或者继承某些特定的类，Struts是侵入式设计框架。 - 非侵入式设计
引入了框架，对现有的类结构没有影响，我们在设计时一般都是使用非侵入式设计，Hibernate是非侵入式的设计框架，Spring框架也是非侵入式设计框架。
- 侵入式设计
控制反转 Inversion on Control
需要什么就创建什么，这属于需求驱动型，这是”控制正转”，而将对象的创建交给外部容器完成，这叫作控制反转，想要拿到别人创建的对象，必须有一个可以获取该对象的公用的接口。控制反转主要是用来解决对象创建的问题(对象创建交给其它容器)- 依赖注入
处理对象的依赖关系，先有控制反转后才出现依赖注入。解决对象创建完之后，对象关系的处理就是依赖注入(通过set方法依赖注入)
- 依赖注入
AOP 面向切面编程
切面，简单来说可以理解为一个类，由很多重复代码形成的类。举例来说包括：事务、日志、权限等。
Spring框架六大模块功能
Spring开发步骤
- 下载Spring的源代码，并将其中的jar包导入到项目中
由于项目中的jar包很多，所以导入的方法与之前在小型项目中新建lib文件夹并将jar包复制进行的方法不一样，采用的方法为:新建Java项目，右键–>properties–>Java Build Path–>Add Libray–>User Libray–>next–>User Libraries–>New–>输入要新建的Library的名字，完成之后点击确定–>Add External JARs，将外部的Spring的Jar包导入到项目中，一般情况下需要建立下面的几个Jar包，要添加的Jar包见附件。
- 书写Spring mvc核心配置文件
- 该文件通常被命名为applicationConetxt.xml或者bean.xml，首先需要在该xml文件中添加schema部分，该部分的代码如下:
<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"
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">
beans>- 得到容器对象
package com.jpzhutech.spring;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
public class App {
//通过工厂类得到容器创建的对象
@Test
public void testIOC1() throws Exception{
//创建对象
//User user = new User(); //在Spring之前创建对象的方法
//现在将对象的创建交给Spring的IOC容器
Resource resource = new ClassPathResource("com/jpzhutech/spring/applicationContext.xml"); //在这里一定要注意导入spring的包
//创建容器对象(bean工厂)，也称为IOC容器=工厂类+applicationContext.xml文件
BeanFactory factory = new XmlBeanFactory(resource);
//得到容器创建的对象
User user = (User)factory.getBean("user");
System.out.println(user);
}
//直接得到IOC容器对象，该方法比较方便，在后续的ssm学习中，采用该方法创建对象
@Test
public void testIOC2() throws Exception{
//得到容器对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("com/jpzhutech/spring/applicationContext.xml");
//从容器中获取bean
User user = (User)applicationContext.getBean("user");
System.out.println(user);
}
}
<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"
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 id="user" class="com.jpzhutech.spring.User"> bean>
beans>//注意该类没有构造函数，创建对象时使用Spring的特性去创建
package com.jpzhutech.spring;
public class User {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}bean对象创建的细节
Spring为我们默认创建的对象时单例的，但是可以在xml中配置单例或者多例模式。多例模式只有在对象需要的时候才创建对象，而对于单例模式，在容器创建之前就已经创建好了对象，整个应用只有这一个对象，这是二者的区别。
- 对象创建能否写死？不能，Spring在配置文件中写入要创建的对象，随时进行更改
- 对象创建的细节
- 对象数量
- action 多个 维护成员变量 此时采用prototype参数值
- service 一个 不需要维护公共变量 此时采用singleton参数值
- dao 一个 不需要维护公共变量 此时采用singleton参数值
- 创建时间
- action 访问的时候创建 采用prototype参数值
- service 启动的时候创建 采用singleton参数值
- dao 启动的时候创建 采用singleton参数值
- 对象数量
<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"
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 id="user" class="com.jpzhutech.spring.User" scope="prototype" lazy-init="default" > bean>
beans>SpringIOC容器
SpringIOC容器是Spring的核心内容，作用是用于对象的创建，解决对象之间的依赖关系。
- applicationContext.xml
<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"
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 id="user1" class="com.jpzhutech.spring.User" scope="prototype" lazy-init="default" > bean>
<bean id="user2" class="com.jpzhutech.spring.User">
<constructor-arg value="100" index="0" type="int" >constructor-arg>
<constructor-arg value="jpzhu" index="1" type="java.lang.String" >constructor-arg>
bean>
<bean id="str" class="java.lang.String" scope="singleton">
<constructor-arg index="0" value="Jack" type="String">constructor-arg>
bean>
<bean id="user3" class="com.jpzhutech.spring.User">
<constructor-arg value="100" index="0" type="int" >constructor-arg>
<constructor-arg ref="str" index="1" type="java.lang.String" >constructor-arg>
bean>
<bean id="factory" class="com.jpzhutech.spring.ObjectFactory">bean>
<bean id="user4" factory-bean="factory" factory-method="getInstance">bean>
<bean id="user5" factory-method="getInstance_static" class="com.jpzhutech.spring.ObjectFactory">
<constructor-arg value="101" type="int">constructor-arg>
<constructor-arg value="jiamin" type="String">constructor-arg>
bean>
beans> - Application.java
package com.jpzhutech.spring;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
@SuppressWarnings("deprecation")
public class App {
//通过工厂类得到容器创建的对象
@Test
public void testIOC1() throws Exception{
//创建对象
//User user = new User(); //在Spring之前创建对象的方法
//现在将对象的创建交给Spring的IOC容器
Resource resource = new ClassPathResource("com/jpzhutech/spring/applicationContext.xml"); //在这里一定要注意导入spring的包
//创建容器对象(bean工厂)，也称为IOC容器=工厂类+applicationContext.xml文件
BeanFactory factory = new XmlBeanFactory(resource);
//得到容器创建的对象
User user = (User)factory.getBean("user");
System.out.println(user);
}
//直接得到IOC容器对象，该方法比较方便，在后续的ssm学习中，采用该方法创建对象
@Test
public void testIOC2() throws Exception{
//得到容器对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("com/jpzhutech/spring/applicationContext.xml");
//从容器中获取bean
User user1 = (User)applicationContext.getBean("user1");
User user2 = (User)applicationContext.getBean("user2"); //使用带参数的构造函数
User user3 = (User)applicationContext.getBean("user3"); //使用带参数的构造函数
System.out.println(user1);
System.out.println(user2.getName());
//System.out.println((String)applicationContext.getBean("str")); //使用在配置文件中创建的对象
System.out.println(user3.getName());
User user4 =(User)applicationContext.getBean("user4");
System.out.println("user4对象为:"+user4);
User user5 = (User)applicationContext.getBean("user5");
System.out.println("user5对象为:"+user5);
}
}
- User.java
package com.jpzhutech.spring;
public class User {
private int id;
private String name;
public User() {
super();
}
public User(int id, String name) {
super();
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + "]";
}- ObjectFactory.java
package com.jpzhutech.spring;
public class ObjectFactory {
//工厂实例方法创建对象
public User getInstance(){
return new User();
}
//工厂静态方法创建对象
public static User getInstance_static(int id , String name){
return new User(id,name);
}
}对象依赖关系
对象依赖关系解决的问题是如何给Spring中的属性赋值，属性赋值的方法和代码测试如下
- 通过构造函数
- 通过set方法给属性注入值
- 内部bean，逻辑较为复杂，一般不推荐使用
- p名称空间，该方法优化leset方法给属性注入值
- 自动装配，该方法一般不用了解即可
- 注解
applicationContext.xml
<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"
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 id="user1" class="com.jpzhutech.property.User" lazy-init="default" >
<constructor-arg value="10" index="0" type="int">constructor-arg>
<constructor-arg value="jpzhu" index="1" type="String" >constructor-arg>
bean>
<bean id="user2" class="com.jpzhutech.property.User" >
<property name="id" value="101">property>
<property name="name" value="jiamin">property>
bean>
<bean id="user3" class="com.jpzhutech.property.User" >
<property name="id" value="10000">property>
<property name="name">
<bean id = "str" class="java.lang.String" >
<constructor-arg value="Jack">constructor-arg>
bean>
property>
bean>
<bean id="string1" class="java.lang.String" >
<constructor-arg value="Rose">constructor-arg>
bean>
<bean id="user4" class="com.jpzhutech.property.User" p:name-ref="string1">bean>
<bean id="name" class="java.lang.String" >
<constructor-arg value="Fuck">constructor-arg>
bean>
<bean id="user5" class="com.jpzhutech.property.User" autowire="byName">bean>
<context:component-scan base-package="com.jpzhutech" >context:component-scan>
beans>
- App.java
package com.jpzhutech.property;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
private ApplicationContext applicationContext;
@Test
public void testProperty() throws Exception{
//创建IOC容器
applicationContext = new ClassPathXmlApplicationContext("com/jpzhutech/property/applicationContext.xml");
//user1通过构造函数创建对象
User user1 = (User)applicationContext.getBean("user1");
System.out.println("id:"+user1.getId()+" name:"+user1.getName() );
//user2通过set方法为属性注入值
User user2 = (User)applicationContext.getBean("user2");
System.out.println("id:"+user2.getId()+" name:"+user2.getName());
//user3内部bean构造对象，逻辑容易出错
User user3 = (User)applicationContext.getBean("user3");
System.out.println("id:"+user3.getId()+" name:"+user3.getName());
//利用p名称空间构造对象
User user4 = (User)applicationContext.getBean("user4");
System.out.println("id:"+user4.getId()+" name:"+user4.getName());
//自动装配
User user5 = (User)applicationContext.getBean("user5");
System.out.println("id:"+user5.getId()+" name:"+user5.getName());
//注解方式给属性注入值
}
}
- User.java
package com.jpzhutech.property;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
@Component
public class User {
private int id;
@Resource //这种注解方式是根据类型进行查找的，必须要确保该类型只有一个变量，所以我们一般情况还是要明确给出其中参数的
private String name;
public User() {
super();
}
public User(int id, String name) {
super();
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + "]";
}
}