Spring学习笔记

1.Spring框架的描述
　　1.Spring是一个开源框架
　　2.Spring为简化企业级应用开发而生
　　3.Spring是一个IoC/DI和AOP容器框架
2.具体描述Spring
　　1.轻量级:Spring是非侵入式的-基于Spring开发的应用中的对象可以不依赖于Spring的API
　　2.依赖注入/控制反转 DI/IoC
　　3.面向切面编程AOP aspect oriented programming
　　4.容器:Spring是一个容器,因为它包含并且管理应用对象的生命周期
　　5.框架:Spring实现了使用简单的组件配置组合成一个复杂的应用,在Spring中可以使用XML和Java注解组合这些对象
　　6.一站式:在IoC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库(实际上Spring自身也提供了展现层SpringMVC和持久层SpringJDBC)
3.搭建Spring开发环境导入jar包
　　com.springsource.net.sf.cglib-2.2.0.jar
　　com.springsource.org.aopalliance-1.0.0.jar
　　com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
　　commons-logging-1.1.3.jar
　　spring-aop-4.2.2.RELEASE.jar
　　spring-beans-4.2.2.RELEASE.jar
　　spring-context-4.2.2.RELEASE.jar
　　spring-core-4.2.2.RELEASE.jar
　　spring-expression-4.2.2.RELEASE.jar
4.DIP、IoC、DI以及IoC容器等名词
　　1.依赖倒置原则（DIP）：一种软件架构设计的原则（抽象概念）。
　　　　依赖倒置原则，它转换了依赖，高层模块不依赖于低层模块的实现，而低层模块依赖于高层模块定义的接口。通俗的讲，就是高层模块定义接口，低层模块负责实现。
　　　　DIP的优点：
　　　　　　系统更柔韧：可以修改一部分代码而不影响其他模块。
　　　　　　系统更健壮：可以修改一部分代码而不会让系统崩溃。
　　　　　　系统更高效：组件松耦合，且可复用，提高开发效率。
　　2.控制反转（IoC）：一种反转流、依赖和接口的方式（DIP的具体实现方式）。
　　　　依赖对象不在被依赖模块的类中直接通过new来获取
　　3.依赖注入（DI）：IoC的一种实现方式，用来反转依赖（IoC的具体实现方式）。
　　　　1.构造函数注入
　　　　2.属性注入setter方法
　　　　3.接口注入
　　4.IoC容器(例:SpringIoC)：依赖注入的框架，用来映射依赖，管理对象创建和生存周期（DI框架）。

示例代码IoC/DI

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

public class User {
    private String name;
    private int age;
    private Address address;
    private List<String> list;
    private Map<String,Object> map;
    private Set<String> set;
    private int [] num;
    private Properties prop;
    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 Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    public List<String> getList() {
        return list;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    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 int[] getNum() {
        return num;
    }
    public void setNum(int[] num) {
        this.num = num;
    }
    public Properties getProp() {
        return prop;
    }
    public void setProp(Properties prop) {
        this.prop = prop;
    }
    public User() {
        super();
        // TODO Auto-generated constructor stub
    }
    public User(String name, int age, Address address, List<String> list, Map<String, Object> map, Set<String> set,
            int[] num, Properties prop) {
        super();
        this.name = name;
        this.age = age;
        this.address = address;
        this.list = list;
        this.map = map;
        this.set = set;
        this.num = num;
        this.prop = prop;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + ",
 address=" + address + ",
 list=" + list + ",
 map=" + map
                + ",
 set=" + set + ",
 num=" + Arrays.toString(num) + ",
 prop=" + prop + "]";
    }
    
}

public class Address {
    private String city;
    private String street;
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    public String getStreet() {
        return street;
    }
    public void setStreet(String street) {
        this.street = street;
    }
    public Address(String city, String street) {
        super();
        this.city = city;
        this.street = street;
    }
    public Address() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Address [city=" + city + ", street=" + street + "]";
    }
    
}

public interface HelloInter {

    public abstract void show();

}

public class HelloSpring implements HelloInter {
    private User user;
    
    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public void show(){
        System.out.println(user);
        
    }

    public HelloSpring(User user) {
        super();
        this.user = user;
    }

    public HelloSpring() {
        super();
        System.out.println("HelloSpring");
    }
    
}

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

/**
 * 依赖注入DI/控制反转
 * 注入类型：对象/数组/集合/基本数据类型和字符串/属性类
 * 注入方式：setter方法/构造器
 * 实现形式：xml文件
 * @author Administrator
 *
 */
public class Test {

    public static void main(String[] args) {

        ApplicationContext app = new ClassPathXmlApplicationContext(
                "applicationContext-hello.xml");

        HelloInter hello = (HelloInter) app.getBean("hello");

        hello.show();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean id="hello" class="com.eduask.liusheng.hello.HelloSpring">
    <property name="user" ref="user"></property>
    </bean>
    <bean id="user" class="com.eduask.liusheng.hello.User">
        <property name="name" value="张三"></property>
        <property name="age" value="18"></property>
        <property name="address" >
            <bean class="com.eduask.liusheng.hello.Address">
                <property name="city" value="杭州"></property>
                <property name="street" value="文三路"></property>
            </bean>
        </property>
        <property name="list">
            <list>
                <value>1</value>
                <value>2</value>
                <value>3</value>
                <value>4</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>a</value>
                <value>b</value>
                <value>c</value>
                <value>d</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="m1" value="一" />
                <entry key="m2" value="二" />
            </map>
        </property>
        <property name="num">
            <array>
                <value>5</value>
                <value>6</value>
                <value>7</value>
                <value>8</value>
            </array>
        </property>
        <property name="prop">
            <props>
                <prop key="username">root</prop>
                <prop key="password">root</prop>
            </props>
        </property>
    </bean>
    
    <bean id="address1" class="com.eduask.liusheng.hello.Address">
        <constructor-arg name="city" value="杭州"></constructor-arg>
        <constructor-arg name="street" value="保俶路"></constructor-arg>
    </bean>
</beans>

测试结果:
User [name=张三, age=18,
address=Address [city=杭州, street=文三路],
list=[1, 2, 3, 4],
map={m1=一, m2=二},
set=[a, b, c, d],
num=[5, 6, 7, 8],
prop={password=root, username=root}]