大概内容:
1.Spring框架的介绍
2.Spring容器（IOC控制反转）
3.Spring容器的简单演示
Spring框架介绍
spring是JavaEE的应用程序框架，也是以IOC和AOP为核心的轻量级容器框架，能够对JavaBean的生命周期进行管理；spring框架可以单独使用，也可以和struts、hibernate等组合使用。
spring框架架构:
Spring框架的优缺点：
优点：
1.轻量级的容器框架，没有侵入性
2.通过Spring容器更加容易组合对象之间的关系，面向接口编程，降低耦合
3.AOP技术更好的进行功能扩展，遵循OCP开发原则
缺点：业务功能比较依赖Spring特有的功能和Spring环境
Spring容器(IOC控制反转)
Spring容器是Spring框架最基础的部分，通过依赖注入（DI，也叫控制反转IOC）来实现对JavaBean的管理，其中一个最基本的概念——–BeanFactory是任何Spring应用的核心，也是工厂模式的一个实现，它使用IOC将应用配置和依赖说明从实际的应用代码中分离出来，使各个层次的代码不再具有绝对的依赖性，实现一定程度上的解耦。
在实际项目中，Spring容器其实就是配置一个xml文件（文件名一般用applicationContext.xml，一般位置放在和src下面的地方，这里都是以Java项目为基础），在此之前先需要写一个JavaBean的类Person：
//Person.java
/*
* Spring中的JavaBean类尽量都写成标准形式:set和get方法、空参构造方法
*/
public class Person {
private String name;
private Integer age;
public Person() {
}
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;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}<!-- aaplicationContext.xml -->
<?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"
xmlns:aop="http://www.springframework.org/schema/aop"
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
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
">
<!-- singleton表示单例，即每次都是拿到同一个实例，默认为singleton -->
<bean id="p1" class="cn.hncu.domain.Person" scope="
singleton">
<property name="name" value="Jack"></property>
<property name="age" value="22"></property>
</bean>
<!-- prototype为原型作用域，即每次创建的是一个新对象 -->
<bean id="p2" class="cn.hncu.domain.Person" scope="prototype">
<property name="name" value="Rose"></property>
<property name="age" value="25"></property>
</bean>
</beans>我对Spring容器的理解：可以说就是一个工厂，在整个项目中所有需要以及可能用到的实例对象，都能通过Spring来帮我们完成创建对象的工作，而我们只需要直接拿过来用就行了，这样做的很大好处就是类和类之间的依赖关系没那么强了，降低了耦合性。
IOC（Inversion of Control）：控制反转的基本概念是不直接创建对象，通过在Xml配置文件中描述创建Bean的方式，在需要使用到Bean是，再通过依赖注入（DI）对属性进行赋值。
Spring中注入有三种方式：set注入、接口注入、构造注入，其中接口注入和构造注入不常使用，这里就只演示set注入：
<bean id="user" class="cn.hncu.demo1.Person">
<property name="pname" value="Tom">
</property>
<property name="page" value="21">
</property>
</bean>
Spring中Bean的作用域有四种：即singleton（单例）、prototype（多实例）、request、session四种。
1.singleton表示单例，即在Spring容器中共享一个Bean实例，并且所有对Bean的请求，只要id和该Bean定义相匹配，拿到的都是同一个Bean实例。
2.prototype表示多实例，即一个Bean对应多个实例，每一次请求都会拿到一个新的Bean实例
3.request表示每次请求都会拿到新的Bean实例，同时该Bean实例仅在当前HTTPRequest中有效
4.session表示每次请求都会拿到一个新的Bean实例，同时该Bean实例仅在当前HTTPSession中有效
Spring容器的简单演示(Java项目中演示)
1.创建好JavaBean的类
//User.java
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class User {
private String name;
private Integer age;
private Cat cat;
private List<String> addrs;
private Map<String,Object> map;
private Set<String> set;
private Object[] objs;
public User() {
}
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;
}
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
public List<String> getAddrs() {
return addrs;
}
public void setAddrs(List<String> addrs) {
this.addrs = addrs;
}
public Map<String, Object> getMap() {
return map;
}
public void setMap(Map<String, Object> map) {
this.map = map;
}
public Set<String> getSet() {
return set;
}
public void setSet(Set<String> set) {
this.set = set;
}
public Object[] getObjs() {
return objs;
}
public void setObjs(Object[] objs) {
this.objs = objs;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + ", cat=" + cat + ", addrs=" + addrs + ", map=" + map + ", set=" + set + ", objs=" + Arrays.toString(objs) + "]";
}
}
//Cat.java
public class Cat {
private String name;
private String hobby;
public Cat() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
@Override
public String toString() {
return "Cat [name=" + name + ", hobby=" + hobby + "]";
}
}2.配置文件
<!-- applicationContext.xml -->
<?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"
xmlns:aop="http://www.springframework.org/schema/aop"
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
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
">
<!-- 注意，所有bean要尽量写标准的形式，要有空参构造，setter-getter方法 -->
<!-- 导入其它xml配置文件 -->
<import resource="cat.xml"/>
<bean id="user" class="cn.hncu.demo2.User">
<property name="name" value="Jack"></property>
<property name="age" value="23"></property>
<!-- 属性变量是一个bean,ref表示引用已经定义好的cat1 -->
<property name="cat" ref="cat1"></property>
<!-- 属性变量是一个List -->
<property name="addrs">
<list>
<value>益阳</value>
<value>上海</value>
<value>北京</value>
<value>天上</value>
</list>
</property>
<!-- 属性变量是一个Map -->
<property name="map">
<map>
<entry key="name" value="Mike" />
<entry key="age" value="20" />
</map>
</property>
<!-- 属性变量是一个Set -->
<property name="set">
<set>
<value>111</value>
<value>222</value>
<value>333</value>
</set>
</property>
<!-- 属性变量是一个Object[], 集合嵌套 -->
<property name="objs">
<array>
<value>字符串</value>
<!-- 引用外部bean -->
<ref bean="cat2"/>
<!-- 内部匿名bean -->
<bean class="cn.hncu.demo2.Cat">
<property name="name" value="灰太狼"></property>
<property name="hobby" value="抓羊"></property>
</bean>
<list>
<value>element1</value>
<value>element2</value>
<value>element3</value>
</list>
</array>
</property>
</bean>
</beans>
-----------------------------------------------------------------
<!-- cat.xml -->
<?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"
xmlns:aop="http://www.springframework.org/schema/aop"
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
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
">
<bean id="cat1" class="cn.hncu.demo2.Cat">
<property name="name" value="Tom"></property>
<property name="hobby" value="fish"></property>
</bean>
<bean id="cat2" class="cn.hncu.demo2.Cat">
<property name="name" value="Rose"></property>
<property name="hobby" value="singing"></property>
</bean>
</beans>3.通过配置文件读取Bean
注意：Spring 框架需要我们手动去导包，否则项目无法编译成功，直接报错，关于Spring包可以去网上下载，这就不展示了。因为Spring的包比较多，我们可以按需进行导包，此处演示需要导的包如下：
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Demo2 {
@Test
public void demo(){
ApplicationContext ctx = new ClassPathXmlApplicationContext("cn/hncu/demo2/demo2.xml");//配置文件的位置
User user = ctx.getBean("user", User.class);
System.out.println(user);
}
}
4.运行结果
总结：简单的了解了一下Spring框架、IOC技术以及演示了Spring容器，这些都是Spring的基础的知识点，其中IOC容器是Spring的两大核心技术之一。
扫一扫
2098
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
