Spring学习手札（一）

 

Spring能作什么

1. 能根据配置文件建立及组装对象之间的依赖关系；

2. 面向切面编程，能帮助咱们无耦合的实现日志记录，性能统计，安全控制等；

3. 提供第三方数据访问框架(如Hibernate)，并且本身也提供了一套JDBC访问模板方便访问数据库；

4. 很是简单的管理数据库事务；

5. 集成第三方Web框架（如Struts1/2），并且自己有Spring MVC方便搭建web层

6. 与Java EE整合，与更多技术整合（好比缓存）

 

Spring的特点

1. 方便解耦，简化开发

　Spring IoC完成对象建立，依赖关系维护等

2. AOP的支持

　Spring提供面向切面编程，实现拦截，监控等

3. 声明式事务管理

　只需经过配置完成对事务的管理，而无需手动操做

4. 方便测试

　支持Junit4，能够经过注解方便测试

5. 方便集成其余框架

　一直在提供并完善各类框架（如Struts，MyBatis，Hibernate等）

6. 下降开发难度，一站式开发项目

　提供各类优秀前端框架，以及后台框架，一站式开发网站

 

Spring的定义

先看看百度百科的解释

Spring框架是一个轻量级的DI/IoC和AOP容器的开源框架；

Spring为了解决企业应用开发的复杂性而建立的；

Spring的用途不只限于服务器端的开发，只是为了简化Java开发。从简单性、可测试性和松耦合的角度而言，任何Java应用均可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来讲，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。

Spring使用基本的JavaBean来完成开发。

 

先了解一下

Spring Boot  经过整合通用实践，更加自动，智能的依赖管理，Spring Boot提供了各类典型应用系统的通用开发基础，因此它是以应用为中心的一个框架集合。

Spring Cloud  可认为是在Spring Boot的升级版，提供了构建分布式系统的通用模块，包含服务发现和服务注册，分布式配置管理，负载均衡，分布式诊断等各类子系统，是构建微服务的一把好手

还有针对特定领域的Spring Security,Spring Data等

 

Spring框架结构

 

• Data Access/Integration层包含有JDBC、ORM、OXM、JMS和Transaction模块。
• Web层包含了Web、Web-Servlet、WebSocket、Web-Porlet模块。
• AOP模块提供了一个符合AOP联盟标准的面向切面编程的实现。
• Core Container(核心容器)：包含有Beans、Core、Context和SpEL模块。
• Test模块支持使用JUnit和TestNG对Spring组件进行测试。

 

Bean规范

每个类实现了Bean的规范才能有Spring来接管

    必须有个公有类

    有无参数构造函数

    用公共方法暴露内部成员属性（getter，setter ）

Bean的生命周期

   

Bean的做用域

Spring定义了多种Bean做用域，可基于这些做用域建立bean，包括：

    单例（Singleton）：在整个应用中，只建立一个bean实例

    原型（Prototype）：每次注入或者经过Spring应用上下文获取的时候，都会建立一个新的bean实例

    会话（Session）：在web应用中，为每一个会话建立一个bean实例

请求（Request）：在web应用中，为每一个请求建立一个bean实例。默认状况下，Spring应用上下文中全部bean都是做为单例的形式建立。也就是说，无论既定的一个bean被注入到其余bean多少次，每次所注入的都是同一个实例。

 

IoC了解一下

一种设计思想。就是将本来在程序中手动建立对象的控制权，交由Spring框架来管理。不用new对象，而直接从Spring那里获取对象。

 

开始Spring的Coding漫漫路 

1. 新建Java项目，命名 spring

2.新建lib目录，并添加jar包，

 

3.开始编写程序

　　3.1 在src下新建bean包，而后新建User类

package bean;

public class User {
    private Integer id;
    private String name;
    private String gender;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

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

}

View Code

 

　　3.2 在src下新建 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 name="beanUser" class="bean.User">
        <property name="id" value="1001"></property>
        <property name="name" value="Jesse"></property>
        <property name="gender" value="male"></property>
    </bean>

</beans>

View Code

 

4.测试程序

　　4.1 在src下新建test类

import bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {

    @Test
    public void demo1() {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                new String[]{"applicationContext.xml"});
        User user = (User) context.getBean("beanUser");
        System.out.println(user.getId());
        System.out.println(user.getName());
        System.out.println(user.getGender());
    }
}

 运行结果： 

 

DI：Dependency Injection (依赖注入)

Spring 在建立对象的过程当中，将对象依赖属性(简单值，集合，对象)经过配置设值给该对象。或者说拿到对象的属性，已经被注入到了相关值了，能够直接使用。

1. 在bean下新建 SaySomething类

package bean;

public class SaySomething {
    private User user = null;

    public User getUser() {
        return user;
    }

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

    public String sayHi() {
        return user.getId() + " " + user.getName() + " " + user.getGender();
    }
}

View Code

 

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 name="beanUser" class="bean.User">
        <property name="id" value="1001"></property>
        <property name="name" value="Jesse"></property>
        <property name="gender" value="male"></property>
    </bean>

    <bean name="saySomething" class="bean.SaySomething">
        <property name="user" ref="beanUser"></property>
    </bean>

</beans>

View Code

 

3.在test.java里，添加新的方法，测试上面代码

  @Test
    public void demo2() {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                new String[]{"applicationContext.xml"});
        SaySomething saySomething = (SaySomething) context.getBean("saySomething");
        System.out.println(saySomething.sayHi());
    }

 运行结果： 

 

AOP Aspect Oriented Program 面向切面编程

Aspect Oriented Program面向切面编程，经过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP采起横向抽取机制，取代了传统纵向继承体系重复性代码

      核心业务，好比登录，CUD

      周边功能，统计，日志，事务管理。在spring的面向切面编程AOP思想里，即被定义为切面

      在面向切面的思想里，核心业务功能和切面功能单独开发，而后把两个组合在一块儿，就是AOP 

目的：AOP 可以将那些与业务无关，却为业务模块所共同调用的逻辑或责任（事务，日志，权限等）封装起来，便于减小系统的重复代码，下降模块间的耦合度，并有利于将来的可拓展性和可维护性。

AOP实现原理

    AOP底层将采用代理机制进行实现

    接口+实现类：spring采用jdk的动态代理Proxy

    实现类：spring采用cglib字节码加强