Spring学习1之入门环境及搭建

什么是Spring

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

EE开发分成三层结构

• WEB层:Spring MVC.
• 业务层:Bean管理:(IOC)
• 持久层:Spring的JDBC模板.ORM模板用于整合其他的持久层框架.

Spring优点？

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

Spring的版本

Spring的入门案例:(IOC)

1. IOC的底层实现原理
   
   IOC：Inversion of Control 控制反转. 指的是 对象的创建权反转(交给)给Spring.作用是实现了程序的解耦合.

开发步骤：

• 步骤一：下载Spring的开发包

官网：http://spring.io/
下载地址：http://repo.springsource.org/libs-release-local/org/springframework/spring

• 步骤二:创建web项目,引入Spring的开发包:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.pp</groupId>
    <artifactId>springday1</artifactId>
    <version>1.0-SNAPSHOT</version>


    <dependencies>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>

        <!--spring相关的jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>
    </dependencies>


    <!--为了让src下的包都编译进去-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>


    </build>


</project>

• 步骤三:引入相关配置文件: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"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    
</beans>

• 步骤四：编写domain包的类

package com.pp.domain;

import java.util.List;

public class User {

    private String[] arrs;
    private List<String> a;
}

• 步骤五:编写相关的类:

1.UserService

  public interface UserService {
    public void sayhello();
}

2.UserServiceImpl

public class UserServiceImpl implements UserService {
    private String name;

    public String getName() {
        return name;
    }

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

    public void sayhello() {
        System.out.println("Hello spring");
    }
 }

• 步骤六:在applicationContext.xml完成配置：

<bean id="userService" class="com.pp.demo1.UserServiceImpl"/>  <!--demo1案例-->

这里的id通常写父类的小写，class写具体的指向那个类。

• 步骤七:编写测试程序:

/*spring的编程模式*/  //内部的那方法
//    @Test
    public void run1() {
       ApplicationContext context = newClassPathXmlApplicationContext("applicationContext.xml");
        UserServiceImpl bean = (UserServiceImpl)context.getBean("userService");
        bean.sayhello();
    }

@Test是junit的一个测试，只要在这里标识，运行该部分代码，就可以执行。该部分代码，首先先创建了一个工厂，通过工厂解析ApplicationContext.xml去获取Bean的示例。

• 步骤八、整体的项目图

使用spring和不使用spring的编程模式有什么区别？

1. 不使用spring的编程模式代码：

 /*不用spring 的编程模式*/
 public void run() {
        UserServiceImpl service = new UserServiceImpl();
        service.sayhello();
    }

2.使用spring的编程模式代码同步骤六

 /*spring的编程模式*/  //内部的那方法
//    @Test
    public void run1() {
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserServiceImpl bean = (UserServiceImpl)context.getBean("userService");
        bean.sayhello();
    }

从上面代码可以知道，不使用spring的编程，没调用一次都会去创建，然后调用其方法。代码之间的而耦合度高。
以上内容是本人平时学习所记录的 ，如有说法不准确或者错误的地方，欢迎各位前来指正。

后续

以下内容属于进阶的部分，可以选择行跳过

一）通过对象工厂去拿对象和调用对象的方法。

BeanFactory继承图:

我们可以看到ClassPathXmlApplicationContext对象继承的终点是BeanFactory，也就是对象工厂，所以在这里我们创建一个对象工厂，通过对象工厂的方式去拿去对象，然后调用对象的方法。具体测试代码如下：

 //通过对象工厂去拿
//    @Test
    public void run2() {
        BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        UserServiceImpl bean = (UserServiceImpl)factory.getBean("userService");
        System.out.println("通过对象工厂去拿");
        bean.sayhello();
    }

applicationContext.xml文件还是跟上面一样即：

<bean id="userService" class="com.pp.demo1.UserServiceImpl"/>

运行结果：

BeanFactory和ApplicationContext的区别:

• BeanFactory :是在getBean的时候才会生成类的实例.
• ApplicationContext :在加载applicationContext.xml时候就会创建.

Spring的相关配置:

1. id属性和name属性标签的配置
2. id :Bean起个名字. 在约束中采用ID的约束:唯一. 必须以字母开始，可以使用字母、数字、连字符、下划线、句话、冒号id:不能出现特殊字符.
3. name:Bean起个名字. 没有采用ID的约束. name:出现特殊字符.如果\没有id的话 , name可以当做id使用.

二）工厂的关闭

1.编写applicationContext.xml文件

因为测试的是一个demo所以配置文件不变，依然如下：

<bean id="userService" class="com.pp.demo1.UserServiceImpl"/>

2.编写测试文件

@Test
    public void run3() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserServiceImpl bean = (UserServiceImpl)context.getBean("userService");
        bean.sayhello();
        context.close(); //工厂关闭掉
        System.out.println("工厂关掉了");  //工厂关闭了，但是对象还是可以调用。
        bean.sayhello();
    }

以上代码复制了run1的代码，但是在调用bean.sayhello()后，我们对工厂进行关闭，并且提示工厂关闭，然后再次调用bean.sayhello()查看是否还能调用该方法。

3.代码结果如下：

通过结果可以看到，虽然工厂关闭了，但是通过工厂创建的对象依然可以使用。

以上代码放在托管平台：https://gitee.com/yangforever/project-learning/tree/master/demo/Spring欢迎点击查看