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:[e-mail]">胡龙华</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:[e-mail]">胡龙华</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:[e-mail]">胡龙华</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:[e-mail]">胡龙华</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:[e-mail]">胡龙华</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:[e-mail]">胡龙华</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:[e-mail]">胡龙华</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:[e-mail]">胡龙华</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:[e-mail]">胡龙华</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文档来选择实现类等。这是个很重要的思想。