标签：完成   启动   示例   util   三方   相对   info   exception   lists   

怎样的架构的程序，我们认为是一个优秀的架构？

我们考虑的标准：可维护性好，可扩展性好，性能。

什么叫可扩展性好？

答：就是可以做到，不断的增加代码，但是可以不修改原来的代码的程序。

如何让程序的可维护性好，可扩展性好呢？

业界有一个公认的标准，高内聚，低耦合。

高内聚：就是尽量将代码写在与之功能描述一致的模块中。如User表的操作写在UserDAO里面就不用写在非UserDAO的类里面。

低耦合：就是尽量减少类与类之间的直接关系。（重点）

Spring框架就是通过IoC（控制反转）实现程序的解耦。从而提高程序的维护性和扩展性。

Spring概述

Spring是什么

Spring是一个JavaEE轻量级的一站式开发框架。

JavaEE： 就是用于开发B/S的程序。（企业级）

轻量级：使用最少代码启动框架，然后根据你的需求选择，选择你喜欢的模块使用。

重量级：早期有的EJB，开发一个HelloWorld程序都需要引入EBJ的全部模块

一站式：提供了，表示层（Struts2/SpringMVC），服务层，持久层的所有支持。

Spring框架出现的背景

在世界第一套有Java官方Sun公司推出的企业级开发框架EJB出现后，瞬间风靡全球。被各大公司所应用。

Spring之父，Rod Jonhson是一个音乐博士，在Sun公司的大力推广下，也成为EJB框架的使用者。

在深入研究完EJB框架（由Sun主导开发的一个JavaEE开发框架），无法接收这么一个框架被吹成世界第一，具体查看他吐槽EJB的书《Expert one on one J2EE design and development》

其中突出被他吐槽最厉害的一个点就EJB的重量级，就是只要使用EJB里面任何一个组件。都要将所有EJB的jar导进去。

于是他就提供了一个他的解决方案：轻量级的一站式企业开发框架。

那么什么是轻量级呢？

就是除内核模块（4个jar），其他模块由开发者自由选择使用，同时支持整合其他框架。

也可以称为就是可插拔式开发框架，像插头和插座一样，插上就用。这就是Spring框架核心理念。（Ioc）

那么什么是一站式呢？

就是Spring框架提供涵盖了JavaEE开发的表示层，服务层，持久层的所有组件功能。也就是说，原则上，学完一套Spring框架，不用其他框架就可以完成网站一条流程的开发。

如图：

Spring框架的作用

根据以上章节的描述。Spring是一个JavaEE一站式的开发框架。它提供的功能涵盖了JavaEE程序中的表示层，服务层，持久层功能组件。这意味着，使用了Spring框架，一个框架就可以满足整个JavaEE程序的开发。

但Spring框架，更加强调的是它的轻量级（模块的可插拔）！！也就是说，除了内核以外模块，如果你不想使用可以不用，它能够整合任何第三方的框架。

所以，在现实开发中，Spring主要用于整合其他框架。

总结

1. Spring是一个一站式的企业级（JavaEE）开发框架，意味着，仅仅使用一个Spring框架就可以满足JavaEE开发的表示层，服务层，持久层的开发。
2. Spring强调的理念是，轻量级。意味着Spring提供的功能模块，除了内核模块以外，开发人员可以选择性使用。
3. 所以，Spring框架在现实开发中，主要的功能用于整合，各种开发来开发项目。

Spring框架包

Spring官方网站

https://spring.io/

 框架包的下载

Spring官方提供的Maven方式的项目下载。

但是基于简单入门的原则，我们要通过导入包的方式来学习。需要下载框架的zip包

路径为：http://repo.springsource.org/libs-release-local/org/springframework/spring/

目录说明

包说明

入门示例

Spring之所以可以实现模块的可插拔是支持依赖注入，所谓的依赖注入/控制反转就是不用new就可以创建对象。

需求：使用Spring框架不用new创建一个对象。

配置流程图

1. 创建一个普通的类。
2. 创建一个Spring配置文件，用于描述类与类之间的关系。
3. 创建ApplicationContext容器对象根据Spring配置文件的描述，将对象创建并且放在Spring容器里面。
4. 使用ApplicationContext容器对象的getBean方法，调用Spring容器里面的对象。

配置步骤说明

1. 导入包
2. 创建一个普通的类
3. 创建一个Spring配置文件（去官方文档上拷贝约束）
4. 编写一个测试类,使用ApplicationContext的子类对象根据配置文件创建容器。并且在容器里面获得创建的对象

 配置步骤

第一步：搭建环境

1.创建一个Java项目

2.导入包，Spring的基础支撑包和依赖的日志包复制到lib文件下，并且加入项目中

---导入Spring基础支撑包

 第二步：创建配置文件

1. 在项目的src下面创建配置文件applicationContext.xml中并完成配置文件的约束,约束查找位置(spring框架/docs/spring-framework-reference/html/beans.html)

 第三步：创建对象到容器里面

1. 创建一个类

package gao.com.zj.spring.service;

public class HwlloWrold {
private String name;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void say() {
        System.out.println("你好，世界");
    }

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

      bean id="helloService" class="gao.com.zj.spring.service.HwlloWrold">bean>

beans>

3.测试使用getBean获得容器中的对象。

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import gao.com.zj.spring.service.*;

public class SpringTest {

    @Test
    public void testName() throws Exception {
        // 创建HwlloWrold 对象 :强耦合 正控
        //HwlloWrold service = new HwlloWrold();
        //service.say();
        // 使用Spring框架获取HwlloWrold对象
        // IOC 控制反转（反控），将对象的创建权交给Spring
        // 1. 读取配置文件，启动Spring框架，创建Spring容器对象
 // ApplicationContext c = new ClassPathXmlApplicationContext("applicationContext.xml");
//ClassPathXmlApplicationContext:通过classpath路径直接获得加载的xml文件（推荐使用）
//FileSystemXmlApplicationContext：通过文件路径来获得加载的xml文件。
 ClassPathXmlApplicationContext c = new ClassPathXmlApplicationContext("applicationContext.xml");
       //2.从Spring的容器对象中获取HwlloWrold对象
         HwlloWrold bean = c.getBean("helloService",HwlloWrold.class);
        bean.say();
    }

}

 Spring的IOC控制反转和依赖注入-重点-spring核心之一

IoC：Inverse of Control（控制反转）:

读作“反转控制”，更好理解，不是什么技术，而是一种设计思想，好比于MVC。就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。

正控：若调用者需要使用某个对象，其自身就得负责该对象的创建。

反控：调用者只管负责从Spring容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了Spring框架。

（Don’t call me ,I’ll call you）

DI：Dependency Injection（依赖注入）

从字面上分析：

IoC：指将对象的创建权，反转给了Spring容器；

DI ：指Spring创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设值给该对象。

IoC和DI其实是同一个概念的不同角度描述，DI相对IoC而言，明确描述了“被注入对象依赖IoC容器配置依赖对象”。

Container：容器，在生活中容器就是一种盛放东西的器皿，从程序设计角度看作是装对象的对象，因为存在对对象的存入、取出等操作，所以容器还要管理对象的生命周期。

1.1. IoC（控制反转）的概述

Spring号称是一个可以实现模块可插拔的JavaEE开发框架。那么它是如何实现程序的可插拔的呢？

实现程序可以插拔的核心理念就是，控制反转（Inversion of Control，英文缩写为IoC）

所谓的控制反转，就是将代码的调用权从调用方转移给被调用方（服务提供方）。

如图所示：

1. 强耦合调用方式

将A调用B的对象修改为C类的对象，修改的是调用方的代码，所以我们认为代码的调用权在调用方。

1. 基于IoC（控制反转）的调用方式

将上图的需求，修改为使用Ioc的调用代码方式。就是将代码的控制权从调用方修改为被调用方，意味着，代码的调用权转移给被调用方（我们也称为服务方），不用修改调用方的的代码

只要修改配置文件就实现对象的切换。

如下图：将A类调用B类的对象修改为C类的对象，修改的是被调用方的配置文件的代码，所以代码的调用权转移到了被调用方。通过控制反转，我们可以实现增加模块或者移除模块统一由配置文件关联，增加或者移除模块，配置XML配置文件即可。

我们将代码的调用权（控制权）从调用方转移给被调用方（服务提供方）的设计模式称为控制反转（IoC）

根据上图可以的得出，实现一个IoC的框架，必须要解决两个问题：

1.被调用方（服务方），在程序启动时就要创建好对象，放在一个容器里面。

2.调用方使用一个接口或类的引用（不用使用new），就可以创建获得对象。

我们将这种不用new，而是根据接口或者类的引用就可以从被调用的容器里获得创建的对象的方式称为依赖注入。

所以，控制反转（Ioc），就是依赖注入加上面向接口的编程思想的实现。

在这里，我们首先抓住一个重点：Spring之所以可以实现可插拔程序，是实现了不用new，使用类或接口就可以获得获得对象！

案列：

1.创建一个接口（HelloWorld），然后两个实现类（Hello1,Hello2）

2.在创建一个调用类（cliet）

3.使用spring来控制使用哪个实现类

4.测试

标签说明

alias标签

作用：为已配置的bean设置别名

 bean标签的配置

 bean标签作用

用于声明一个类,在启动Spring框架的时候根据该配置的类创建对象到容器里面

属性说明

1.1.3. Bean作用范围

scope="作用域"/>

在开发中主要使用 scope="singleton"、 scope="prototype"

对于MVC中的Action/Controller使用prototype类型，其他使用singleton

在Web开发的三层架构中

Web：一般都是多例

Service ：单例

DAO ：单例

实例化Bean的四种方式

构造器实例化（无参数构造器），最标准，使用最多

2.通过静态方法工厂创建（了解）

初始化和销毁方法

比如DataSource,SessionFactory最终都需要关闭资源:在Bean销毁之前,都要调用close方法.

    init-method="该类中初始化方法名" destroy-method="该类中销毁方法名">

init-method：bean生命周期初始化方法,对象创建后就进行调用

destroy-method:容器被销毁的时候，如果bean被容器管理，会调用该方法。

default-init-method

分析原理:

如果bean的scope="prototype",那么容器只负责创建和初始化，它并不会被spring容器管理。交给用户自己调用.

Spring依赖注入 DI

DI：Dependency Injection（依赖注入）

从字面上分析：

IoC：指将对象的创建权，反转给了Spring容器；

DI ：指Spring创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设值给该对象。

IoC和DI其实是同一个概念的不同角度描述，DI相对IoC而言，明确描述了“被注入对象依赖IoC容器配置依赖对象”。

所谓的依赖注入，就是属性不创建对象，通过配置文件的配置将Spring容器里面的对象注入给对应的属性

依赖注入有四种方式

setter注入，（属性注入）

 构造器注入

使用哪种注入方式比较好（setter？构造器？）？

1，如果一个类必须依赖另一个类才能正常运行，用构造器；

2，但是构造器的参数如果过多，构造器很难看；

3，更多的还是使用setter注入；

4，可以使用@Required标签来要求一个属性必须注入

p命名空间注入

 集合类型值注入

在处理的数据中，

有标量类型=基础数据类型以及包装类+String  -- value属性

也有Spring容器里面的对象  --ref属性

还要很多数据JDK内置的数据结构：

1. 键值对 Map 、Properties
2. 数组
3. 集合Set、List

package gao.com.zj.spring.client;

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

public class cliet {
    private String[] arr;
    private List list;
    private Set set;
    private Map map;
    private Properties prop;
    

    public String[] getArr() {
        return arr;
    }
    public void setArr(String[] arr) {
        this.arr = arr;
    }
    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 getProp() {
        return prop;
    }
    public void setProp(Properties prop) {
        this.prop = prop;
    }
    @Override
    public String toString() {
        return "CollectionBean [arr=" + Arrays.toString(arr) + ", list=" + list + ", set=" + set + ", map=" + map
                + ", prop=" + prop + "]";
    }
    
}

xml version="1.0" encoding="UTF-8"?>
beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p"
    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="collectionBean" class="cn.zj.spring.pojo.CollectionBean">
        
        
        property name="arr">
            array>
                value>javavalue>
                value>cvalue>
                value>c++value>
            array>
        property>
        
        
        property name="list">
            list>
                value>AAvalue>
                value>BBvalue>
                value>BBvalue>
                value>CCvalue>
            list>
        property>
        
        property name="set">
            set>
                value>AAvalue>
                value>BBvalue>
                value>BBvalue>
                value>CCvalue>
            set>
        property>
        
        
        property name="map">
            map>
                entry key="key1" value="value1"/>
                entry key="key2" value="value2"/>