SpringIOC技术学习---day1

本篇博客知识点

1.Spring框架IOC技术的原理

2.Spring框架IOC技术的原理的示意图

3.如何从零开始搭建Spring开发环境，如何一步一步导包

4.如何配置Spring 的XML文档

5.实例代码演示Spring技术如何完成 servlet层、service层和DAO层的解耦。

Spring框架IOC技术的原理

Spring 是容器框架，创建bean，维护bean之间的关系，音痴spring可以管理web层，持久层，业务层，dao层，spring可以配置各个层的组件，并且维护各个层的关系

我画了个我理解的原理图

Spring框架IOC技术的简单案例演示

第一步：配置好Spring的包

去Spring官网选择你想要下载的版本,先下载下来

也可以从这个地址下：http://repo.springsource.org/libs-release-local/org/springframework/spring/

下载好如下



主要是第一个dist文件，lib目录下有我们需要的包，docs开发手册。都很有用的



按照这个路径打开spring-framework-4.3.2.RELEASE-dist\spring-framework-4.3.2.RELEASE\docs\spring-framework-reference\htmlsingle，index.html



大概是这样—



接下来就可以建立项目，先要导入两个核心包bean core包

其他的包再根据需要一步一步的导，因为背不下来



再从刚刚的开发手册—那个网页找到核心代码，这一句。



这个时候会出错，明显是没导包，代码里面有那么大的context。。。所以就是要去找context包，dist里面的lib目录里面—jar才是包 剩下两个不是的





导包之后Build Path之后就没有编译错误了。这个时候就需要xml配置文件了—就是前面示意图的容器 xml文档怎么写？ —-开发者手册



写好之后大概是这样



后面还要用到aop和context 所以前面的名称空间一起加了（方便快捷键）。

<?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:aop="http://www.springframework.org/schema/aop"
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/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> </beans>

之后就绪运行前面的main 函数，会继续报错（看蓝色区域）



所以需要 org.apache.commons.logging.LogFactory—就还需要这个包，这个包前面libs目录是没有的需要自己下载（百度一下，应该能下载到）



继续Build Path 运行main 函数，会继续报错，错误信息就是我们需要的包的信息（注意蓝色区域）–去libs下面找到support包



找到包~ 这个



然后继续Build Path 运行main 函数 异常信息 导包 expression





把这个导了后运行就不会出错了

所以总共需要的包 全在这儿



第二步：如何把一个对象配置到Spring容器中来—关键在于这个对象要写 Setter Getter 函数 和 空参构造函数

第一种：把简单类 Person.java配到Spring 容器中，并且取出

Person.java

public class Person {
private String name;
private String age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public Person() {
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}

}

配置文件 核心配置是一个bean标签

id 表示唯一标识（理解：Spring容器是个HashMap id就是相当于拿到这个bean的Key）

class 表示这个类（底层是类放射实现所以需要找到这个类）

scope: 有4个值 prototype：每次拿到的都是一个新的原型对象（每次重新new）request 一个request:请求对应一个新对象 session 一个session会话对应一个新对象 “singleton” （默认值）单例，每次来拿都是同一个

<bean id="p1" class="cn.hncu.domain.Person"  scope="singleton">
<property name="age" value="22"></property>
<property name="name" value="Jack"></property>
</bean>

测试： 成功拿到Person对象，并且输出两个的HashCode,单例



第二种：把包含List/Map/Set/Object[]属性的对象封装到容器，并从容器中取出

User.java

package cn.hncu.domain;

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

public class User {
private String username;
private String pwd;
private Map<String, Object> map;
private List<String> list;
private Set<String> set;
private Object[] objs;
public User() {
super();
}

public Object[] getObjs() {
return objs;
}

public void setObjs(Object[] objs) {
this.objs = objs;
}

public String getUsername() {
return username;
}

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

public String getPwd() {
return pwd;
}

public void setPwd(String pwd) {
this.pwd = pwd;
}

public Map<String, Object> getMap() {
return map;
}

public void setMap(Map<String, Object> map) {
this.map = map;
}

public List<String> getList() {
return list;
}

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

public Set<String> getSet() {
return set;
}

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

@Override
public String toString() {
return "User [username=" + username + ", pwd=" + pwd + ", map=" + map
+ ", list=" + list + ", set=" + set + ", objs="
+ Arrays.toString(objs) + "]";
}

}

applicationContext.xml文件

<bean id="u1" class="cn.hncu.domain.User" scope="singleton" >
<!--  封装普通类型属性 -->
<property name="username" value="用户"/>
<property name="pwd" value="12345"/>
<!--  封装List类型属性 -->
<property name="list">
<list>
<value>长沙</value>
<value>城院</value>
</list>
</property>
<!-- 封装Set类型属性 -->
<property name="set">
<set>
<value>达哥</value>
<value>胡龙华</value>
</set>
</property>
<!-- 封装Map类型属性 -->
<property name="map">
<map>
<entry key="苹果"  value="5"/>
<entry key="西瓜"  value="2"/>
</map>
</property>
<!-- 封装Object[]类型属性 -->
<property name="objs">
<array>
<list>
<value>1</value>
<value>2</value>
</list>
<bean id="p2" class="cn.hncu.domain.Person">
<property name="age" value="18"/>
<property name="name" value="Tom"/>
</bean>
</array>
</property>
</bean>

测试：输出结果为：User [username=用户, pwd=12345, map={苹果=5, 西瓜=2}, list=[长沙, 城院], set=[达哥, 胡龙华], objs=[[1, 2], Person [name=Tom, age=18]]]



第三种：把 一个对象中包含另一个对象的数据存入Spring容器，并从中取出—引用外部Bean外部

如Person，有只猫， Person对象就包含一个Cat属性

Cat.java

package cn.hncu.domain;
/**
* @author<a href="mailto:953801304@qq.com">胡龙华</a>
*/
public class Cat {
private String name;
private String hobby;
public Cat() {
}
public String getName() {
return name;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Cat [name=" + name + ", hobby=" + hobby + "]";
}

}

Person.java

package cn.hncu.domain;
/**
* @author<a href="mailto:953801304@qq.com">胡龙华</a>
*/
public class Person {
private String name;
private String age;
private Cat cat;
public Person() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", cat=" + cat + "]";
}

}

applicationContext.xml主要的Bean

<bean id="p1" class="cn.hncu.domain.Person">
<property name="name" value="Jack"/>
<property name="age" value="25"/>
<!-- 外部引用bean -->
<property name="cat" ref="c1"></property>
</bean>
<!-- 外部导入其他容器 -->
<import resource="cn/hncu/domain/cat.xml"/>

</beans>

测试：运行结果：Person [name=Jack, age=25, cat=Cat [name=Tom, hobby=fish]]

用Spring框架IOC技术的演示servlet层、service层和dao层之间的层间调用

模拟向数据库存储学生信息为例：就是本篇博客开头的示意图

我实际类的名字修改成如下图



第一步：写好servlet层、service层和dao层 之间的接口和实现类

先展示一下包结构



实际代码如下：

Student.java值对象

package cn.hncu.demo;
/**
* @author<a href="mailto:953801304@qq.com">胡龙华</a>
*/
public class Student {
private String sno;
private String school;
private String name;
private int age;
public String getSno() {
return sno;
}
public void setSno(String sno) {
this.sno = sno;
}
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student() {
}
@Override
public String toString() {
return "Student [sno=" + sno + ", school=" + school + ", name=" + name
+ ", age=" + age + "]";
}

}

dao层 接口 IStudentDAO.java

package cn.hncu.demo.dao;

import cn.hncu.demo.Student;
/**
* @author<a href="mailto:953801304@qq.com">胡龙华</a>
*/
public interface IStudentDAO {
public Student save(Student stu);
}

dao层 实现类1.StudentMySql.java

package cn.hncu.demo.dao;

import cn.hncu.demo.Student;
/**
* @author<a href="mailto:953801304@qq.com">胡龙华</a>
*/
public class StudentMySql implements IStudentDAO{

@Override
public Student save(Student stu) {
stu.setSchool("城市学院");
stu.setSno("1406602");
stu.setName("胡龙华");
stu.setAge(21);
System.out.println("模拟完成：数据已经存入MySQL数据库");
return stu;
}

}

dao层 实现类2.StudentOracle

package cn.hncu.demo.dao;

import cn.hncu.demo.Student;
/**
* @author<a href="mailto:953801304@qq.com">胡龙华</a>
*/
public class StudentOracle implements IStudentDAO{

@Override
public Student save(Student stu) {
stu.setSchool("城市学院");
stu.setSno("1406601");
stu.setName("小妹妹");
stu.setAge(18);
System.out.println("模拟完成：数据已经存入Oracle数据库");
return stu;
}

}

service层接口：IServiceStud.java

package cn.hncu.demo.service;

import cn.hncu.demo.Student;
/**
* @author<a href="mailto:953801304@qq.com">胡龙华</a>
*/
public interface IServiceStud {
public Student save(Student stu);
}

service层实现类IServoceStudImp.java

package cn.hncu.demo.service;

import cn.hncu.demo.Student;
import cn.hncu.demo.dao.IStudentDAO;
/**
* @author<a href="mailto:953801304@qq.com">胡龙华</a>
*/
public class IServoceStudImp implements IServiceStud{
//注入Dao
// Spring  --- setter getter 空参构造
private IStudentDAO studDao = null;

public IServoceStudImp() {
}

public IStudentDAO getStudDao() {
return studDao;
}

public void setStudDao(IStudentDAO studDao) {
this.studDao = studDao;
}

@Override
public Student save(Student stu) {

return studDao.save(stu);
}

}

servlet层SpringServlet.java

package cn.hncu.demo.servlet;

import cn.hncu.demo.Student;
import cn.hncu.demo.service.IServiceStud;
/**
* @author<a href="mailto:953801304@qq.com">胡龙华</a>
*/
public class SpringServlet {
//注入Service
// Spring  --- setter getter 空参构造
private IServiceStud service=null;

public SpringServlet() {
}
public IServiceStud getService() {
return service;
}
public void setService(IServiceStud service) {
this.service = service;
}

public Student excute(){
Student s = new Student();
Student stud =service.save(s);
return stud;
}
}

接下来是最核心的spring容器代码 MVC.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:aop="http://www.springframework.org/schema/aop"
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/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> 
<!--  下面两个bean 就相当于new好了两个Dao层的实现类 -->
<bean id="MySQL" class="cn.hncu.demo.dao.StudentMySql"/>
<bean id="Oracle" class="cn.hncu.demo.dao.StudentOracle"/>
<!--  Service通过XML文档来调用Dao层 -->
<bean id="ServiceImp" class="cn.hncu.demo.service.IServoceStudImp">
<!-- ref来选择不同的实现类： ref="MySQL" 或者  ref="Oracle" -->
<property name="studDao" ref="MySQL"></property>
</bean>
<!-- Servlet层通过XML文档来调用Service层 -->
<bean id="Servlet" class="cn.hncu.demo.servlet.SpringServlet">
<property name="service" ref="ServiceImp"></property>
</bean>

</beans>

测试：客户端可以通过修改配置文件，选择将数据出入不同的数据库（这里模拟了，选择不同的实现类）

选择MySQL



选择Oracle



总结：SpringIOC技术很简单，只要学会配置好xml容器就行了，但是很强大，使的我们以前的调用的依赖关系解除，完全同XML文档来选择实现类等。这是个很重要的思想。