Spring入门

1.Spring简介

Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

2.Spring的优点

方便解耦，简化开发
Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理
AOP编程的支持
Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
声明式事务的支持
只需要通过配置就可以完成对事务的管理，而无需手动编程
方便程序的测试
Spring对Junit4支持，可以通过注解方便的测试Spring程序
方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis等）的直接支持
降低JavaEE API的使用难度
Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低

3.Spring的模块

4.Spring Ioc

IoC（控制反转）不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。
何为反转，哪些方面反转了：传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

5.Spring Ioc 的快速入门案例

添加Spring核心开发包到pom.xml

 
      org.springframework
      spring-core
      4.3.14.RELEASE
    
    
      org.springframework
      spring-context
      4.3.14.RELEASE
    
    
      org.springframework
      spring-beans
      4.3.14.RELEASE
    
    
      org.springframework
      spring-expression
      4.3.14.RELEASE

public interface UserService {
    public void sayHello();
}

public class UserServiceImpl implements UserService{
    //添加属性
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void sayHello() {
        System.out.println("测试，hello " + name);
    }
}

传统方式实现

public class IocTest {
    /**
     * 传统方式实现
     */
      @Test
    public void TradTest(){
        // UserService userService = new UserServiceImpl();
        UserServiceImpl userService = new UserServiceImpl();
        userService.setName("小姐姐");
        userService.sayHello();
    }
    
}

Spring的方式实现

注意：id 属性在IOC容器中必须是唯一的，如果Bean的名称中含有特殊字符，就需要使用name

/**
     * Spring的方式实现
     */
    @Test
    public void SpringTest(){
        //创建Spring的工厂
        /** 读取磁盘系统中的配置文件 **/
        //ApplicationContext applicationContext = new FileSystemXmlApplicationContext("c:\\applicationContext.xml");
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过工厂获取类
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.sayHello();
    }

总结

Ioc 控制反转的概念，就是将原本在程序中手动创建UserService对象的控制权，交由Spring框架管理。简单说，就是创建UserService对象控制权被反转到了Spring 框架。

DI 依赖注入的概念，就是Spring创建这个对象的过程中，将这个对象所依赖的属性注入进去。

复杂类型的属性注入

public class CollectionBean {
    private String[] arrs; // 数组类型

    private List list;// List集合类型

    private Set set; // Set集合类型

    private Map map;// Map集合类型

    private Properties properties; // 属性类型

    public String[] getArrs() {
        return arrs;
    }

    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }

    public List getList() {
        return list;
    }

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

    public Set getSet() {
        return set;
    }

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

    public Map getMap() {
        return map;
    }

    public void setMap(Map map) {
        this.map = map;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public String toString() {
        return "CollectionBean{" +
                "arrs=" + Arrays.toString(arrs) +
                ", list=" + list +
                ", set=" + set +
                ", map=" + map +
                ", properties=" + properties +
                '}';
    }
}

public class SpringDemo5 {
    @Test
    public void demo1(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

       CollectionBean collectionBean = (CollectionBean)applicationContext.getBean("collectionBean");

       System.out.println(collectionBean);
    }
}