第一章 框架

1.由来：

由于编程的发展,从刚开始的代码复用，即将一些公用的方法抽取在一个类中，到将更多的代码抽取出来形成一个jar包，在到将多个jar包抽取出来放到一个文件中，就形成了框架的概念。框架让程序员写更少的代码，实现更强大的功能。

2.功能

1.专注于某个领域的解决方案，像银行项目中，要有大数据计算，计算的过程基本上一至，可能传的数据不一样，把整个计算的过程抽取出来；在把数据挖掘等操作，当做完项目后，我们把这些功能操作抽取出来，封装到一起。因为一类的项目中，所具有的功能都是大同小异的，当别人在做类似的项目的时候，直接把写好的框架拿来用就可以了，不同的地方，自定义就好。
2.框架就像一栋房子，它由开发商建好，是一个半成品，房子的户型是一样的，但是，当业主把房子买到手以后，室内的装修根据个人的喜好，来进行装修，到最后，每个房子就都不是一样的了。
3.高度抽象的，可重用的代码设计
4.优点
  1）简化开发
  2）开源产品（免费）
  3）更新速度快
5.缺点
  1）学习难度大，重在理解，然后用于实践当中

第一节 三大主流框架之一Spring框架

1.简介

  1）Spring是一个开源框架
  2）Spring是为简化企业级开发而生的，使用Spring，JavaBean就可以实现很多以前要靠EJB才能实现的功能。同样的功能，在EJB中腰通过繁琐的配置和复杂的代码才能够实现，但是在Spring中却非常的简洁和【容易
  3）Spring是一个IOC（DI）和AOP容器框架
  4）优良特性
     1⃣️非侵入式：基于Spring开发的应用中的对象可以不依赖于Spring的API
     2⃣️依赖注入：DI-Dependency Injection，反转控制最经典的实现（IOC）
     3⃣️面向切面编程：AOP-Aspect Oriented Programming
     4⃣️容器：Spring是一个容器，它包含并且管理对应对象的生命周期
     5⃣️组件化：Spring实现了使用简单的组件配置合成一个复杂的应用。在Spring中可以使用XML和java注解组合这些对象
     6⃣️一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库，实际上，Spring本上也有表述层的SpringMVC和持久层的SpringJDBC

2.功能模块

1. Test：Spring的单元测试模块，我们通常不用，用JUNITY单元测试
2. Core Container：核心处理器（IOC模块）：这个模块都由那些Jar包组成：Beans、Core、Context、SpEL组成
3. AOP模块，Aspect模块
4. Instrumentation模块，设备交互模块
5. Messaging模块消息模块
6. 数据库模块：JDBC、ORM、OXM、JMS、Transcations组成
7. web模块：WebSocket、Servlet、Web、Portlet组成

3. IOC&DI（思想）

1.IOC：inverse Of Controller即控制反转
控制：指的是资源（组件）获取的方式
不用Spring框架时，需要一个组件时，都是程序猿主动去创建资源
控制反转：是变主动为被动，是被动的接受某个资源，需要一个容器去管理需要的组 件，当程序用的时候是由容器交给程序，而不是程序猿主动创建；
组件的创建和获取都交给某个容器来完成，这个容器就叫做IOC容器。即容器里面都创建好了所有组件，用的时候返回就可以了。

2.DI：Dependency Injection，依赖注入
观察组件运行的时候依赖那些其他组件。容器负责将依赖的组件注入到资源中。

4. IOC程序

1. HelloWorld
    导包
   commons-logging-1.1.3.jar
   spring-beans-4.0.0.RELEASE.jar
   spring-context-4.0.0.RELEASE.jar
   spring-core-4.0.0.RELEASE.jar
   spring-expression-4.0.0.RELEASE.jar

2. 创建一个配置文件
IDE可以自动生成，不用插件
3. 创建一个bean类，Person

package com.fgy.beans;
/**
 1. Created by snow_fgy on 2017/9/14.
 */
public class Person {

    private String lastName;
    private String gender;
    private double salary;

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

1. 在.xml文件中注册
   注册组件，这里注册的组件是由Spring的IOC容器进行管理的
   使用bean标签注册一个组件，一个组件就是一个bean标签
   Class指定组件的类型
   id组件的唯一标识
   配置具体信息用property标签配置
   name指定属性名
   value指属性值

<?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="person01" class="com.fgy.bean.Person">
        <property name="lastName" value="小明"></property>
        <property name="gender" value="男"></property>
        <property name="salary" value="9989.99"></property> 
    </bean>
</beans>

5.对IOC容器的测试

public void test() {
        //1.获取到IOC容器的ApplicationContext
        ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
        //2.从容器中获取组件
        Person bean = (Person) ioc.getBean("person01");
        System.out.println(bean);
    }
    ```
6.测试结果
Person [lastName=小明, gender=男, salary=9989.99]
 3. property是靠set方法赋值的
     - 测试一下：在一个属性的set方法中，写一个输出语句，在运行程序，观察，打印了set方法中的输出语句  
    - 容器里面的组件已经帮我们创建好了对象，我们只需要获取就好
    - 在容器启动的时候，就已经帮我创建好对象了，不是获取的时候创建
    - 默认组件创建好对象，再次获取的时候返回的是之前就创建好的对象，默认的情况下是单例对象
 4. 例一根据bean的类型获取bean的实例
`   //按照组件类型获取对象
        Person bean = ioc.getBean(Person.class);`
        但是在配置文件中有两个类型相同的bean组件，用以上方法，就会报错`NoUniqueBeanDefinitionException`
    这样的话，要想还拿到对个类型相同的bean组件，那么还的需要用id获取
  例二 通过构造器为bean的属性赋值
      1. 通过构造器的参数名，给参数赋值

<bean id="person03" class="com.fgy.bean.Person">
    <constructor-arg name="lastName" value="麻子"></constructor-arg>
    <constructor-arg name="gender" value="女"></constructor-arg>
    <constructor-arg name="salary" value="1100"></constructor-arg>
</bean> 

2. 不写属性名，默认根据参数对应的位置进行赋值，也可以根据索引值来进行设置

<bean id="person03" class="com.fgy.bean.Person">
        <constructor-arg value="女" ></constructor-arg>
        <constructor-arg value="麻子" ></constructor-arg>
        <constructor-arg value="1100"></constructor-arg>
</bean>

根据index来设置对应的构造器参数的值

<bean id="person03" class="com.fgy.bean.Person">
    <constructor-arg value="女" index="1"></constructor-arg>
    <constructor-arg value="麻子" index="0"></constructor-arg>
    <constructor-arg value="1100"></constructor-arg>
</bean>

---

例三 通过类型不同区分重载的构造器
通过index来指定位置可能会出现问题，可以这样解决
①为index指定位置，添加一个type属性，指定这个参数的具体类型，不会自动装箱拆箱对于基本类型

<constructor-arg value="1100" type="double"></constructor-arg>

---

例四 通过p命名空间为bean赋值
①xml命名空间：用来区别重复标签

<bean id="person01" class="com.fgy.bean.Person"
    p:lastName="强子" p:gender="男" p:email="11@126" p:salary="998">
</bean>

例五 测试使用null

    <bean id="person02" class="com.fgy.bean.Person">
        <property name="lastName">
            <null></null>
        </property>
    </bean>

例六 引用其他的bean
① 外部引用
在XML文件中先创建一个要引用的bean

    <bean id="book01" class="com.fgy.bean.Book">
        <property name="bookName" value="水浒传"></property>
    </bean>

ref:引用外部的bean,ref=”被引用的bean的id”

    <bean id="person02" class="com.fgy.bean.Person">
        <property name="lastName" value="章泽"></property>
        <property name="myBook" ref="book01"></property>
    </bean>

由于book的bean是全局的，在测试类中根据book的bean获取book类的对象，改变book对象的属性值，在引用类person中，现在获取的book对象的属性值，就变为上述改变后的属性值，因为ref就是个引用，外面改变，内部也改变
②内部引用

    <bean id="person02" class="com.fgy.bean.Person">
        <property name="lastName" value="章泽"></property>
        <property name="myBook">
        <!-- 直接给book bean赋值 这是个内部类，不能被外部获取-->
            <bean id="book01" class="com.fgy.bean.Book">
        <property name="bookName" value="童话"></property>
            </bean>
        </property>
    </bean>

例七 使用List类型的集合属性

<bean id="person03" class="com.fgy.bean.Person" p:lastName="章话" p:email="110@126.com">
        <property name="list">
        <!-- <list></list> 只是相当于new了个ArrayList，没有任何元素-->
            <list>
                <!-- 标签体中每个标签都是一个元素 -->
                <bean id="book01" class="com.fgy.bean.Book">
                    <property name="bookName" value="童话2"></property>
                </bean>
                <value>哈哈</value>
            </list>
        </property> 
    </bean>

例八 使用Map类型的集合属性

<bean id="person03" class="com.fgy.bean.Person" p:lastName="章话" p:email="110@126.com">
        <property name="map">
        <!-- <map></map> 只是相当于new了个hashMap，没有任何元素-->
            <map>
                <!-- entry就是一个键值对 -->
                <entry key="key01" value="value01"></entry>
                <entry key="key02" value-ref="person01"></entry>
                <entry key="key03">
                    <bean class="com.fgy.bean.Book" id="book05" p:bookName="红楼梦"></bean>
                </entry>
            </map>
        </property> 
    </bean>

例九 使用prop子元素为Properties类型的属性赋值

<bean id="person03" class="com.fgy.bean.Person" p:lastName="章话" p:email="110@126.com">
        <property name="properties">
        <!-- <props></props> 只是相当于new了个Properties()，没有任何元素-->
            <props>
                <prop key="jdbcurl">jdbc:mysql://localhost:3306/test</prop>
                <prop key="username">toot</prop>
                <prop key="password">123456</prop>
                <prop key="driverClass">com.mysql.jdbc.driver</prop>
            </props>
        </property>
    </bean>

例十 通过util名称空间创建集合类型的bean
我们可以在外部定义一个list，供别人使用
id属性的赋值，要不然其他bean引用时，找不到这个list

    <util:list id="listId">
        <ref bean="person03"/>
        <bean class="com.fgy.bean.Book"></bean>
        <value>哈哈</value>
    </util:list>