Spring Framework01-Spring起步-有解無憂

一、Spring前言

講Spring之前先寫段代碼，體會一下Java創建物件的方式，這塊你理解了對后面有好處！

1、原始時代

直接new創建物件，代碼如下：

//User.java
package com.ty.bean;

public class User {
    private String username;
    private String password;

   /**
 	* 省略有參無參構造，getter/setter方法
 	*/
}

//UserDao.java
public interface UserDao {
    void getUser(String username,String password);
}

//UserDao的實作類UserDaoImpl.java
public class UserDaoImpl implements UserDao {
    @Override
    public void getUser(String username, String password) {
        System.out.println("用戶名："+username+"\t密碼："+password);
    }
}

//UserService.java
public interface UserService {
    void getUser(String username,String password);
}

//UserService的實作類UserServiceImpl.java
public class UserServiceImpl implements UserService {
    private UserDao userDao= new UserDaoImpl();
    @Override
    public void getUser(String username, String password) {
        userDao.getUser(username,password);
    }
}

正常來講這里還需要寫一個UserController，但是我們只是測驗，所以就寫一個TestUser類

public class TestUser {
    @Test
    public void test(){
        UserService userService=new UserServiceImpl();
        userService.getUser("jack","root");
    }
}

這是之前學習經常寫的方式用來完成某種功能，service層呼叫dao層；UserService的實作類呼叫UserDao的實作類，想象一下：如果我們業務更改了，增加了一個UserService的實作類BUserServiceImpl，使用的時候代碼就要變成這樣

public class TestUser {
    @Test
    public void test(){
        //UserService userService=new UserServiceImpl();
        UserService userService=new BUserServiceImpl();
        userService.getUser("jack","root");
    }
}

這就是所謂的耦合，呼叫的時候要修改代碼，即直接new ，顯然不符合面向物件的設計原則---------開閉原則

2、過渡時代

工廠方式，再原來的代碼修改一下

先創建一個BeanFactory.java檔案

//創建工廠類，BeanFactory.java
public class BeanFactory {
    public static UserService getUser(){
        return new UserServiceImpl();
    }
}

這樣使用的時候就變成這樣

 @Test
    public void test(){
        UserService userService= BeanFactory.getUser();
        userService.getUser("jack","root");
    }

這樣雖然使用的時候沒有耦合了，但是BeanFactory里面還是有代碼耦合的即：return UserService，那怎么辦呢?可以利用反射創建物件

public class BeanFactory {
    public static UserService getUser(){
        UserService userService=null;
        try {
            Class<?> clazz = Class.forName("com.ty.service.UserServiceImpl");
            userService= (UserService) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return userService;
    }

這樣比直接new好多了，減少了耦合，但是還有些不妥，獲取類限定名的時候還是需要改來改去，即：

Class<?> clazz = Class.forName("com.ty.service.UserServiceImpl");

下面我們可以用properties屬性組態檔存盤檔案限定名，代碼如下：

userService=com.ty.service.UserServiceImpl

#這就實作把具體的類限定名和代碼相分離，未來只需要修改此組態檔即可

public class BeanFactory {
    private static UserService userService;
    //創建Properties物件來加載properties屬性組態檔
    private static Properties environment = new Properties();
    private static InputStream resource;

    static {

        //加載applicationContext.properties組態檔
        resource = BeanFactory.class.getResourceAsStream("/applicationContext.properties");
        try {
            environment.load(resource);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                resource.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static UserService getUserService() throws Exception {

        Class<?> clazz = Class.forName(environment.getProperty("userService"));
        userService = (UserService) clazz.newInstance();
        return userService;
    }
}

這樣未來增加了service代碼，只需要修改properties組態檔即可，例如

public class BUserServiceImpl implements UserService {
    private UserDao userDao= new UserDaoImpl();
    @Override
    public void getUser(String username, String password) {
        System.out.println("B");
        userDao.getUser(username,password);
    }
}

#組態檔就改成這樣
userService=com.ty.service.BUserServiceImpl

//測驗檔案
  @Test
  public void test2() throws Exception {
      UserService userService= BeanFactory.getUserService();
      userService.getUser("jack","root");
  }

我們順便用這種方式把UserService呼叫UserDao進行改進

public static UserDao getUserDao() {
        UserDao userDao=null;
        Class<?> clazz = null;
        try {
            clazz = Class.forName(environment.getProperty("userDao"));
            userDao = (UserDao) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }

        return userDao;
    }

public class UserServiceImpl implements UserService {
    private UserDao userDao= BeanFactory.getUserDao();
    @Override
    public void getUser(String username, String password) {
        userDao.getUser(username,password);
    }
}

userDao=com.ty.dao.UserDaoImpl

    @Test
    public void test2() throws Exception {
        UserService userService= BeanFactory.getUserService();
        userService.getUser("jack","root");
    }

工廠方法基本設計完成了，但是還有點小問題，那就是每次都需要在BeanFactory工廠類寫一個與其對應的物件創建工廠方法，好麻煩，而且這些方法長得基本差不多，能不能設計一個通用的工廠方法呢，那必須能啊，上代碼

public class BeanFactory {
    private static Properties environment = new Properties();
    private static InputStream resource;

    static {

        //加載applicationContext.properties組態檔
        resource = BeanFactory.class.getResourceAsStream("/applicationContext.properties");
        try {
            environment.load(resource);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                resource.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     *
     * @param key 組態檔對應的userService，userDao
     * @return
     */
   public static Object getBean(String key){
       Object returnedObject=null;
       try {
           Class<?> clazz = Class.forName(environment.getProperty(key));
           returnedObject=clazz.newInstance();
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       } catch (InstantiationException e) {
           e.printStackTrace();
       }
       return returnedObject;
   }
}

userService=com.ty.service.UserServiceImpl

userDao=com.ty.dao.UserDaoImpl

public class UserServiceImpl implements UserService {
    private UserDao userDao= (UserDao) BeanFactory.getBean("userDao");
    @Override
    public void getUser(String username, String password) {
        userDao.getUser(username,password);
    }
}

 @Test
    public void test2() throws Exception {
        UserService userService= (UserService) BeanFactory.getBean("userService");
        userService.getUser("jack","root");
    }
}

這樣一個通用工廠就完成了，這種方式你還需要先自己提供工廠類和方法，我們如果用Spring的話，工廠類不用我們手動實作，Spring提供了工廠

ioc容器創建物件，這種方式我們后面會詳細講解

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser(String username, String password) {
        userDao.getUser(username,password);
    }
}

<?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="userService" >
        <property name="userDao" ref="userDao"></property>
    </bean>

    <bean id="userDao" ></bean>
</beans>

 @Test
    public void test3(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.getUser("jack","root");
    }

這樣我們就把創建物件的方式的一個小Demo寫完了，只就是Spring框架的核心之一：ioc，我們先簡單介紹一下Spring

二、spring介紹

我們常說的 Spring 實際上是指 Spring Framework，而 Spring Framework 只是 Spring 家族中的一個分支而已，那么 Spring 家族都有哪些東西呢？具體可以查看官網：https://spring.io/projects

官網地址：https://spring.io/projects/spring-framework

壓縮包下載地址：https://repo.spring.io/release/org/springframework/spring/

原始碼地址：https://github.com/spring-projects/spring-framework

英文官網可能看不懂，github上還有一個中文網址，只不過不是最新版本的，不過沒太大影響

https://gitee.com/fl_982659186/spring-docs

Spring 是為了解決企業級應用開發的復雜性而創建的，在 Spring 之前，有一個重量級的工具叫做 EJB，使用 Spring 可以讓 Java Bean 之間進行有效的解耦，而這個操作之前只有 EJB 才能完成，EJB 過于臃腫，使用很少，Spring 不僅僅局限于服務端的開發，在測驗性和松耦合方面都有很好的表現，官網有一個簡短的Spring介紹，說明Spring產生的原因

Spring makes programming Java quicker, easier, and safer for everybody. Spring’s focus on speed, simplicity, and productivity has made it the world's most popular Java framework.

總結就是Spring能為我們快速、輕松和安全的進行Java編程
詳細：https://spring.io/why-spring

官網上還有一個Spring的概述

https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/overview.html#overview

中文翻譯：https://gitee.com/fl_982659186/spring-docs/blob/master/pages/overview/overview.md

核心解釋

spring是一個一站式開源框架，

spring是為了簡化企業開發而生的，使得開發變得更加優雅和簡潔，

spring是一個IOC和AOP的容器框架，

? IOC：控制反轉

? AOP：面向切面編程

? 容器：包含并管理應用物件的生命周期，就好比用桶裝水一樣，spring就是桶，而物件就是水

三、Spring 特點

? 1、Spring通過DI、AOP和消除樣板式代碼來簡化企業級Java開發

? 2、Spring框架之外還存在一個構建在核心框架之上的龐大生態圈，它將Spring擴展到不同的領域，如Web服務、REST、移動開發以及NoSQL

? 3、低侵入式設計，代碼的污染極低

? 4、獨立于各種應用服務器，基于Spring框架的應用，可以真正實作Write Once,Run Anywhere的承諾

? 5、Spring的IoC容器降低了業務物件替換的復雜性，提高了組件之間的解耦

? 6、Spring的AOP支持允許將一些通用任務如安全、事務、日志等進行集中式處理，從而提供了更好的復用

? 7、Spring的ORM和DAO提供了與第三方持久層框架的的良好整合，并簡化了底層的資料庫訪問

? 8、Spring的高度開放性，并不強制應用完全依賴于Spring，開發者可自由選用Spring框架的部分或全部

如何簡化開發

? 基于POJO的輕量級和最小侵入性編程

? 通過依賴注入和面向介面實作松耦合

? 基于切面和慣例進行宣告式編程

? 通過切面和模板減少樣板式代碼

四、Spring 框架結構

模塊解釋：
Test:Spring的單元測驗模塊
Core Container:核心容器模塊,主要組件是 BeanFactory是不是好熟悉，上面咱們實作了一個簡易版的BeanFactory
AOP+Aspects:面向切面編程模塊
Instrumentation:提供了class instrumentation支持和類加載器的實作來在特定的應用服務器上使用,幾乎不用
Messaging:包括一系列的用來映射訊息到方法的注解,幾乎不用
Data Access/Integration:資料的獲取/整合模塊，包括了JDBC,ORM,OXM,JMS和事務模塊
Web:提供面向web整合特性

五、ioc初識

ioc（Inversion of Control )：控制反轉，這是一個思想，簡單一句話就是創建物件的控制權利交給Spring的容器我們稍微詳細展開一下

誰控制誰
控制什么
什么是反轉
哪些方面被反轉

先看一下官網如何介紹的

 IoC is also known as dependency injection (DI). It is a process whereby objects define their dependencies (that is, the other objects they work with) only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injects those dependencies when it creates the bean. This process is fundamentally the inverse (hence the name, Inversion of Control) of the bean itself controlling the instantiation or location of its dependencies by using direct construction of classes or a mechanism such as the Service Locator pattern
 
 IOC與大家熟知的依賴注入同理，. 這是一個通過依賴注入物件的程序 也就是說，它們所使用的物件，是通過建構式引數，工廠方法的引數或這是從工廠方法的建構式或回傳值的物件實體設定的屬性，然后容器在創建bean時注入這些需要的依賴， 這個程序相對普通創建物件的程序是反向的（因此稱之為IoC），bean本身通過直接構造類來控制依賴關系的實體化或位置，或提供諸如服務定位器模式之類的機制，

可能稍微晦澀，用現實的事物舉個例子，我們要找女盆友，傳統的方式是你自己按照標準親自一步步篩選，然后就需要打聽她們的興趣愛好、qq號、電話號、微信號等等，想辦法認識她們再繼續下一步事情，控制反轉的方式的話就是有一個婚介所，這個媒介所就是一個容器，里面有很多女生的資料，你把你的標準告訴作業人員，然后剩下的步驟由他們去操作，最后給你就回傳一個符合你標準的女盆友，你就和她談戀愛、結婚就行了，

說到這我們把上面演示過的demo畫圖演示一下

我們總結一下上面說的4個小問題

誰控制誰：以前我們都是手動創建即new所需的物件，程式員自己來控制物件的創建程序，而有了IOC容器之后，就會變成由IOC容器來控制物件
控制什么：實作程序中所需的物件以及所需依賴的物件
什么是反轉：以前我們自己new依賴物件就是正轉，而有了反轉之后，依賴的物件由ioc容器創建后注入到物件中，由主動創建變成了被動接受，這是反轉
哪些方面被反轉：依賴的物件

DI

DI ( Dependency Injection )：依賴注入

很多人把IOC和DI說成一個東西，籠統來說的話是沒有問題的，但是本質上還是有所區別的,希望大家能夠嚴謹一點，IOC和DI是從不同的角度描述的同一件事，IOC是從容器的角度描述，而DI是從應用程式的角度來描述，也可以這樣說，IOC是設計思想，而DI是具體的實作方式

上面的控制反轉概念其實是模糊的（可能只是理解為容器控制物件這一個層面，很難讓人想到誰來維護物件關系），所以后來就有了 “依賴注入” ，這個就很好理解，很直截了當就能說明IOC容器用來維護物件的依賴關系，

六、其它

我們稍微說點其它的，額外說兩個點

一個就是我們面向物件設計的程序盡量達到低耦合，在面向物件設計的軟體系統中，底層的實作都是由N個物件組成的，所有的物件通過彼此的合作，最終實作系統的業務邏輯，

? 需要注意的是，在這樣的組合關系中，一旦某一個物件出現了問題，那么其他物件肯定回有所影響，這就是耦合性太高的緣故，但是物件的耦合關系是無法避免的，也是必要的，隨著應用程式越來越龐大，物件的耦合關系可能越來越復雜，經常需要多重依賴關系，因此，無論是架構師還是程式員，在面臨這樣的場景的時候，都需要減少這些物件的耦合性，

? 耦合的關系不僅僅是物件與物件之間，也會出現在軟體系統的各個模塊之間，是我們需要重點解決的問題，而為了解決物件之間的耦合度過高的問題，我們就可以通過IOC來實作物件之間的解耦，spring框架就是IOC理論最最廣泛的應用，

從上圖中可以看到，當引入了第三方的容器之后，幾個物件之間就沒有了耦合關系，全部物件都交由容器來控制，這個容器就相當于粘合劑，將系統的物件粘合在一起發揮作用，

任何一個語言或者任何一個框架想要立于不敗之地，那么很重要的就是它的生態，Java語言現在為什么那么火爆，就是因為20多年的歷練，出現了很多技術，這些技術被廣泛使用，如果出現新的編程語言想替代Java,短時間內無法替代，Spring框架也一樣，發展到今天，我們都離不開它了，現在很少的公司不用Spring

這些都是Spring家族的產品，而我們現在學的包括不久我更新的SpringMVC都是屬于Spring Framework的范疇

所以我們說Spring不僅僅是框架，它主要是一個生態，幾乎在Spring中能找到JavaEE各種解決方案，Spring框架更新的還很頻繁！

ps:Spring全系列我后面打算都更新一遍，組件多，我會一點點更新，大家也是需要一點點積累！也歡迎大家多多提建議！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/181591.html

標籤：Java

上一篇：獲取jsp頁面中上傳的檔案的絕對路徑

下一篇：Python六大標準資料型別（上）