2. 程式人生 > >spring data jpa（一）

spring data jpa（一）

阿新 • • 發佈：2019-01-09

第1章     Spring Data JPA的快速入門

1.1   需求說明

Spring Data JPA完成客戶的基本CRUD操作

1.2   搭建Spring Data JPA的開發環境

1.2.1      引入Spring Data JPA的座標

使用Spring Data JPA，需要整合Spring與Spring Data JPA，並且需要提供JPA的服務提供者hibernate，所以需要匯入spring相關座標，hibernate座標，資料庫驅動座標等

 

  <properties>

        <spring.version>4.2.4.RELEASE</spring.version>

        <hibernate.version>5.0.7.Final</hibernate.version>

        <slf4j.version>1.6.6</slf4j.version>

        <log4j.version>1.2.12</log4j.version>

        <c3p0.version>0.9.1.2</c3p0.version>

        <mysql.version>5.1.6</mysql.version>

    </properties>

 

    <dependencies>

        <!-- junit單元測試 -->

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.9</version>

            <scope>test</scope>

        </dependency>

       

        <!-- spring beg -->

        <dependency>

            <groupId>org.aspectj</groupId>

            <artifactId>aspectjweaver</artifactId>

            <version>1.6.8</version>

        </dependency>

 

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-aop</artifactId>

            <version>${spring.version}</version>

        </dependency>

 

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>${spring.version}</version>

        </dependency>

 

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context-support</artifactId>

            <version>${spring.version}</version>

        </dependency>

 

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-orm</artifactId>

            <version>${spring.version}</version>

        </dependency>

 

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-beans</artifactId>

            <version>${spring.version}</version>

        </dependency>

 

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-core</artifactId>

            <version>${spring.version}</version>

        </dependency>

       

        <!-- spring end -->

 

        <!-- hibernate beg -->

        <dependency>

            <groupId>org.hibernate</groupId>

            <artifactId>hibernate-core</artifactId>

            <version>${hibernate.version}</version>

        </dependency>

        <dependency>

            <groupId>org.hibernate</groupId>

            <artifactId>hibernate-entitymanager</artifactId>

            <version>${hibernate.version}</version>

        </dependency>

        <dependency>

            <groupId>org.hibernate</groupId>

            <artifactId>hibernate-validator</artifactId>

            <version>5.2.1.Final</version>

        </dependency>

        <!-- hibernate end -->

 

        <!-- c3p0 beg -->

        <dependency>

            <groupId>c3p0</groupId>

            <artifactId>c3p0</artifactId>

            <version>${c3p0.version}</version>

        </dependency>

        <!-- c3p0 end -->

 

        <!-- log end -->

        <dependency>

            <groupId>log4j</groupId>

            <artifactId>log4j</artifactId>

            <version>${log4j.version}</version>

        </dependency>

 

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-api</artifactId>

            <version>${slf4j.version}</version>

        </dependency>

 

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-log4j12</artifactId>

            <version>${slf4j.version}</version>

        </dependency>

        <!-- log end -->

 

       

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <version>${mysql.version}</version>

        </dependency>

 

        <dependency>

            <groupId>org.springframework.data</groupId>

            <artifactId>spring-data-jpa</artifactId>

            <version>1.9.0.RELEASE</version>

        </dependency>

 

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-test</artifactId>

            <version>4.2.4.RELEASE</version>

        </dependency>

       

        <!-- el beg 使用spring data jpa 必須引入 -->

        <dependency> 

            <groupId>javax.el</groupId> 

            <artifactId>javax.el-api</artifactId> 

            <version>2.2.4</version> 

        </dependency> 

         

        <dependency> 

            <groupId>org.glassfish.web</groupId> 

            <artifactId>javax.el</artifactId> 

            <version>2.2.4</version> 

        </dependency>

        <!-- el end -->

    </dependencies>

 

 

1.2.2      整合Spring Data JPA與Spring

 

<?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:aop="http://www.springframework.org/schema/aop"

    xmlns:context="http://www.springframework.org/schema/context"

    xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"

    xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd

        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd

        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd

        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd

        http://www.springframework.org/schema/data/jpa

        http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

   

    <!-- 1.dataSource 配置資料庫連線池-->

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

        <property name="driverClass" value="com.mysql.jdbc.Driver" />

        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/jpa" />

        <property name="user" value="root" />

        <property name="password" value="111111" />

    </bean>

   

    <!-- 2.配置entityManagerFactory -->

    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">

        <property name="dataSource" ref="dataSource" />

        <property name="packagesToScan" value="cn.itcast.entity" />

        <property name="persistenceProvider">

            <bean class="org.hibernate.jpa.HibernatePersistenceProvider" />

        </property>

        <!--JPA的供應商介面卡-->

        <property name="jpaVendorAdapter">

            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">

                <property name="generateDdl" value="false" />

                <property name="database" value="MYSQL" />

                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />

                <property name="showSql" value="true" />

            </bean>

        </property>

        <property name="jpaDialect">

            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />

        </property>

    </bean>

   

   

    <!-- 3.事務管理器-->

    <!-- JPA事務管理器  -->

    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">

        <property name="entityManagerFactory" ref="entityManagerFactory" />

    </bean>

   

    <!-- 整合spring data jpa-->

    <jpa:repositories base-package="cn.itcast.dao"

        transaction-manager-ref="transactionManager"

        entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>

       

    <!-- 4.txAdvice-->

    <tx:advice id="txAdvice" transaction-manager="transactionManager">

        <tx:attributes>

            <tx:method name="save*" propagation="REQUIRED"/>

            <tx:method name="insert*" propagation="REQUIRED"/>

            <tx:method name="update*" propagation="REQUIRED"/>

            <tx:method name="delete*" propagation="REQUIRED"/>

            <tx:method name="get*" read-only="true"/>

            <tx:method name="find*" read-only="true"/>

            <tx:method name="*" propagation="REQUIRED"/>

        </tx:attributes>

    </tx:advice>

   

    <!-- 5.aop-->

    <aop:config>

        <aop:pointcut id="pointcut" expression="execution(* cn.itcast.service.*.*(..))" />

        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />

    </aop:config>

   

    <context:component-scan base-package="cn.itcast"></context:component-scan>

       

    <!--組裝其它 配置檔案-->

   

</beans>

 

 

1.2.3      使用JPA註解配置對映關係

我們使用昨天案例中的Customer實體類物件，已經配置好了對映關係

 

package cn.itcast.entity;

 

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import javax.persistence.Table;

 

/**

 *

 *      * 所有的註解都是使用JPA的規範提供的註解，

 *      * 所以在匯入註解包的時候，一定要匯入javax.persistence下的

 */

@Entity //宣告實體類

@Table(name="cst_customer") //建立實體類和表的對映關係

public class Customer {

   

    @Id//聲明當前私有屬性為主鍵

    @GeneratedValue(strategy=GenerationType.IDENTITY) //配置主鍵的生成策略

    @Column(name="cust_id") //指定和表中cust_id欄位的對映關係

    private Long custId;

   

    @Column(name="cust_name") //指定和表中cust_name欄位的對映關係

    private String custName;

   

    @Column(name="cust_source")//指定和表中cust_source欄位的對映關係

    private String custSource;

   

    @Column(name="cust_industry")//指定和表中cust_industry欄位的對映關係

    private String custIndustry;

   

    @Column(name="cust_level")//指定和表中cust_level欄位的對映關係

    private String custLevel;

   

    @Column(name="cust_address")//指定和表中cust_address欄位的對映關係

    private String custAddress;

   

    @Column(name="cust_phone")//指定和表中cust_phone欄位的對映關係

    private String custPhone;

   

    public Long getCustId() {

        return custId;

    }

    public void setCustId(Long custId) {

        this.custId = custId;

    }

    public String getCustName() {

        return custName;

    }

    public void setCustName(String custName) {

        this.custName = custName;

    }

    public String getCustSource() {

        return custSource;

    }

    public void setCustSource(String custSource) {

        this.custSource = custSource;

    }

    public String getCustIndustry() {

        return custIndustry;

    }

    public void setCustIndustry(String custIndustry) {

        this.custIndustry = custIndustry;

    }

    public String getCustLevel() {

        return custLevel;

    }

    public void setCustLevel(String custLevel) {

        this.custLevel = custLevel;

    }

    public String getCustAddress() {

        return custAddress;

    }

    public void setCustAddress(String custAddress) {

        this.custAddress = custAddress;

    }

    public String getCustPhone() {

        return custPhone;

    }

    public void setCustPhone(String custPhone) {

        this.custPhone = custPhone;

    }

}

 

 

1.3   使用Spring Data JPA完成需求

1.3.1      編寫符合Spring Data JPA規範的Dao層介面

Spring Data JPA是spring提供的一款對於資料訪問層（Dao層）的框架，使用Spring Data JPA，只需要按照框架的規範提供dao介面，不需要實現類就可以完成資料庫的增刪改查、分頁查詢等方法的定義，極大的簡化了我們的開發過程。

 

在Spring Data JPA中，對於定義符合規範的Dao層介面，我們只需要遵循以下幾點就可以了：

 

1.建立一個Dao層介面，並實現JpaRepository和JpaSpecificationExecutor

    2.提供相應的泛型

 

package cn.itcast.dao;

 

import java.util.List;

 

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

 

import cn.itcast.entity.Customer;

 

/**

 * JpaRepository<實體類型別，主鍵型別>：用來完成基本CRUD操作

 * JpaSpecificationExecutor<實體類型別>：用於複雜查詢（分頁等查詢操作）

 */

public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {

}

 

 

這樣我們就定義好了一個符合Spring Data JPA規範的Dao層介面

1.3.2      完成基本CRUD操作

完成了Spring Data JPA的環境搭建，並且編寫了符合Spring Data JPA 規範的Dao層介面之後，就可以使用定義好的Dao層介面進行客戶的基本CRUD操作

 

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations="classpath:applicationContext.xml")

public class CustomerDaoTest {

 

    @Autowired

    private CustomerDao customerDao;

   

    /**

     * 儲存客戶：呼叫save(obj)方法

     */

    @Test

    public void testSave() {

        Customer c = new Customer();

        c.setCustName("傳智播客");

        customerDao.save(c);

    }

   

    /**

     * 修改客戶：呼叫save(obj)方法

     *      對於save方法的解釋：如果執行此方法是物件中存在id屬性，即為更新操作會先根據id查詢，再更新   

     *                      如果執行此方法中物件中不存在id屬性，即為儲存操作

     *         

     */

    @Test

    public void testUpdate() {

        //根據id查詢id為1的客戶

        Customer customer = customerDao.findOne(1l);

        //修改客戶名稱

        customer.setCustName("傳智播客順義校區");

        //更新

        customerDao.save(customer);

    }

   

    /**

     * 根據id刪除：呼叫delete(id)方法

     */

    @Test

    public void testDelete() {

        customerDao.delete(1l);

    }

   

    /**

     * 根據id查詢：呼叫findOne(id)方法

     */

    @Test

    public void testFindById() {

        Customer customer = customerDao.findOne(2l);

        System.out.println(customer);

    }

}

 

 

第2章     Spring Data JPA的內部原理剖析

2.1   Spring Data JPA的常用介面分析

在客戶的案例中，我們發現在自定義的CustomerDao中，並沒有提供任何方法就可以使用其中的很多方法，那麼這些方法究竟是怎麼來的呢？答案很簡單，對於我們自定義的Dao介面，由於繼承了JpaRepository和JpaSpecificationExecutor，所以我們可以使用這兩個介面的所有方法。

 

 

在使用Spring Data JPA時，一般實現JpaRepository和JpaSpecificationExecutor介面，這樣就可以使用這些介面中定義的方法，但是這些方法都只是一些宣告，沒有具體的實現方式，那麼在 Spring Data JPA中它又是怎麼實現的呢？

2.2   Spring Data JPA的實現過程

通過對客戶案例，以debug斷點除錯的方式，通過分析Spring Data JPA的原來來分析程式的執行過程

我們以findOne方法為例進行分析

 

l  代理子類的實現過程

 通過JDKDynamicAopProxy 建立動態代理物件

動態代理物件：simpleJpaRepository 實現了JapRepository 和 JpaSpecificationExecutor。對基本增刪改查進行了封裝。最終通過EntityManager完成增刪改查操作

 

 

 

斷點執行到方法上時，我們可以發現注入的customerDao物件，本質上是通過JdkDynamicAopProxy生成的一個代理物件

 

 

l  代理物件中方法呼叫的分析

 

當程式執行的時候，會通過JdkDynamicAopProxy的invoke方法，對customerDao物件生成動態代理物件。根據對Spring Data JPA介紹而知，要想進行findOne查詢方法，最終還是會出現JPA規範的API完成操作，那麼這些底層程式碼存在於何處呢？答案很簡單，都隱藏在通過JdkDynamicAopProxy生成的動態代理物件當中，而這個動態代理物件就是SimpleJpaRepository

     

   

 

   

通過SimpleJpaRepository的原始碼分析，定位到了findOne方法，在此方法中，返回em.find()的返回結果，那麼em又是什麼呢？

 

   

帶著問題繼續查詢em物件，我們發現em就是EntityManager物件，而他是JPA原生的實現方式，所以我們得到結論Spring Data JPA只是對標準JPA操作進行了進一步封裝，簡化了Dao層程式碼的開發

2.3   Spring Data JPA完整的呼叫過程分析

 

第3章     Spring Data JPA的查詢方式

3.1   使用Spring Data JPA中介面定義的方法進行查詢

在繼承JpaRepository，和JpaRepository介面後,我們就可以使用介面中定義的方法進行查詢

 

l  繼承JpaRepository後的方法列表

 delete

　　刪除

findAll

　　查詢所有

findOne

　　直接載入

getOne

　　底層是getRefresh（）。是延遲載入的

save：

    　　save方法儲存的物件主鍵為null，視為儲存。主鍵存在值，視為修改

 

 

l  繼承JpaSpecificationExecutor的方法列表

   繼承了以 Specification 為引數的動態查詢方法

3.2   使用JPQL的方式查詢

使用Spring Data JPA提供的查詢方法已經可以解決大部分的應用場景，但是對於某些業務來說，我們還需要靈活的構造查詢條件，這時就可以使用@Query註解，結合JPQL的語句方式完成查詢

 

@Query 註解的使用非常簡單，只需在方法上面標註該註解，同時提供一個JPQL查詢語句即可

 

public interface CustomerDao extends JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer> {   

    //@Query 使用jpql的方式查詢。

    @Query(value="from Customer")

    public List<Customer> findAllCustomer();

   

    //@Query 使用jpql的方式查詢。?1代表引數的佔位符，其中1對應方法中的引數索引

    @Query(value="from Customer where custName = ?1")

    public Customer findCustomer(String custName);

}

 

 

此外，也可以通過使用 @Query 來執行一個更新操作，為此，我們需要在使用 @Query 的同時，用 @Modifying 來將該操作標識為修改查詢，這樣框架最終會生成一個更新的操作，而非查詢

 

    @Query(value="update Customer set custName = ?1 where custId = ?2")

    @Modifying

    public void updateCustomer(String custName,Long custId);

 

3.3   使用SQL語句查詢

Spring Data JPA同樣也支援sql語句的查詢，如下：

 

    /**

     * nativeQuery : 使用本地sql的方式查詢

     */

    @Query(value="select * from cst_customer",nativeQuery=true)

    public void findSql();

 

3.4   方法命名規則查詢

顧名思義，方法命名規則查詢就是根據方法的名字，就能建立查詢。只需要按照Spring Data JPA提供的方法命名規則定義方法的名稱，就可以完成查詢工作。Spring Data JPA在程式執行的時候會根據方法名稱進行解析，並自動生成查詢語句進行查詢

 

按照Spring Data JPA 定義的規則，查詢方法以findBy開頭，涉及條件查詢時，條件的屬性用條件關鍵字連線，要注意的是：條件屬性首字母需大寫。框架在進行方法名解析時，會先把方法名多餘的字首擷取掉，然後對剩下部分進行解析。

 

    //方法命名方式查詢（根據客戶名稱查詢客戶）

    public Customer findByCustName(String custName);

 

 

具體的關鍵字，使用方法和生產成SQL如下表所示

 

         

Keyword

Sample

JPQL

    

And

findByLastnameAndFirstname

… where x.lastname = ?1 and x.firstname = ?2

    

Or

findByLastnameOrFirstname

… where x.lastname = ?1 or x.firstname = ?2

    

Is,Equals

findByFirstnameIs,

findByFirstnameEquals

… where x.firstname = ?1

    

Between

findByStartDateBetween

… where x.startDate between ?1 and ?2

    

LessThan

findByAgeLessThan

… where x.age < ?1

    

LessThanEqual

findByAgeLessThanEqual

… where x.age ⇐ ?1

    

GreaterThan

findByAgeGreaterThan

… where x.age > ?1

    

GreaterThanEqual

findByAgeGreaterThanEqual

… where x.age >= ?1

    

After

findByStartDateAfter

… where x.startDate > ?1

    

Before

findByStartDateBefore

… where x.startDate < ?1

    

IsNull

findByAgeIsNull

… where x.age is null

    

IsNotNull,NotNull

findByAge(Is)NotNull

… where x.age not null

    

Like

findByFirstnameLike

… where x.firstname like ?1

    

NotLike

findByFirstnameNotLike

… where x.firstname not like ?1

    

StartingWith

findByFirstnameStartingWith

… where x.firstname like ?1 (parameter bound with appended %)

    

EndingWith

findByFirstnameEndingWith

… where x.firstname like ?1 (parameter bound with prepended %)

    

Containing

findByFirstnameContaining

… where x.firstname like ?1 (parameter bound wrapped in %)

    

OrderBy

findByAgeOrderByLastnameDesc

… where x.age = ?1 order by x.lastname desc

    

Not

findByLastnameNot

… where x.lastname <> ?1

    

In

findByAgeIn(Collection ages)

… where x.age in ?1

    

NotIn

findByAgeNotIn(Collection age)

… where x.age not in ?1

    

TRUE

findByActiveTrue()

… where x.active = true

    

FALSE

findByActiveFalse()

… where x.active = false

    

IgnoreCase

findByFirstnameIgnoreCase

… where UPPER(x.firstame) = UPPER(?1)

    

相關推薦

SpringBoot操作之Spring-Data-Jpa（一）

runt 更新 drive oca 完成 work lin 進入 his Spring-Data-Jpa JPA(Java Persistence API)定義了一系列對象持久化的標準， 目前實現這一規範的產品有Hibernate、TopLink等。 Spring Data

spring data jpa（一）

第1章     Spring Data JPA的快速入門 1.1   需求說明 Spring Data JPA完成客戶的基本CRUD操作 1.2   搭建Spring Data JPA的開發環境 1.2.1 &n

【ORM框架】-- Spring Data JPA（一）

sco blog 產品 mysql- lse log 規範 dao層 標識 本文參考：spring Data JPA入門 【原創】純幹貨，Spring-data-jpa詳解，全方位介紹 Spring Data JPA系列教程--入門 一、Spring Data JP

Spring Data 介紹 （一）

tin 可能 動態 javac 行高 spec 增加 核心概念 一個 簡介 　　Spring Data是什麽 　　　　　　Spring Data是一個用於簡化數據庫訪問，並支持雲服務的開源框架。其主要目標是使得對數據的訪問變得方便快捷 Spring Data JPA能幹什麽

Spring Data Jpa（三）

Spring Data Jpa介紹 A、Spring Data JPA 是 Spring 基於 ORM 框架、JPA 規範的基礎上封裝的套 JPA 應用框架， 可使開發者用極簡的程式碼即可實現對資料的訪問和操作。它提供了包括增刪改查等在內的常用功能， 且易於擴充套件！學習

spring-data-jpa（三） ->今天踩的坑

最近升級使用了Spring boot 2.0 發現Service層報錯時，事物仍然進行了提交。通過查詢各方資料。大致原因歸納為一下幾種： 1、檢查你方法是不是public的 2、你的異常型別是不是unchecked異常  如果我想check異常也想回滾怎麼辦，註解上面寫明異常型別即

spring boot + jpa（一）

        這幾天研究了一下使用spring boot 整合jpa的專案，網上有很多資料但是沒找到比較系統的，這幾天根據網上的一些資料系統的整理了一個完整的專案。        專案使用maven建立，只是做的資料介面，沒有做web，使用jpa操作資料會很方便，但是當需要

spring boot 整合 jpa （一） -- 之基礎配置

spring boot 整合 jpa （二） – 之資料操作 https://blog.csdn.net/qq_41463655/article/details/82939560 spring boot 整合 jpa （三） – 之表關係對映 https://blog.csdn.ne

SpringBoot系列——Spring-Data-JPA（升級版）

　　前言 　　在上篇部落格中：SpringBoot系列——Spring-Data-JPA：https://www.cnblogs.com/huanzi-qch/p/9970545.html，我們實現了單表的基礎get、save（插入/更新）、list、page、delete介面，但是這樣每個單表都要寫著一套

spring boot 整合 jpa （一）

先建立 springboot 專案 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:

Spring整合Hibernate實現Spring Data JPA （簡單使用）

pda artifact framework factor path sta ans 項目結構 pub 直接上代碼： pom.xml <!-- hibernate start --> <!-- spring data jp

spring之註解（一）概述

dsm 的人 src article service 優缺點 中一 auto 數據 Spring的核心是依賴註入（DI），而依賴註入的基礎是依賴信息的配置。這些配置稱之為元數據。在之前的的學習中。一直採用的是基於xml的配置，這些元數據配置在spring內部被註冊成為B

Spring學習筆記（一）

分布式 ransac 解析 工具 files 分布 工廠 根據 使用 Spring學習筆記（一） 因為最近在看《Spring 技術內幕-深入解析Spring 架構與設計原理》，相當於做了個筆記，以及把自己理解的東西記錄下來。 Spring整體架構圖 1.Spring子項目

Spring Data HelloWorld（三）

system out factor 環境搭建 spring string rep ret gda 在 Spring Data 環境搭建（二） 的基礎之上 我們改動 http://www.cnblogs.com/fzng/p/7253068.html 定義個一個接口 繼承

Spring框架初識（一）

持久層 容器 med int reat set map 要求 enter 新的 1. Spring框架概述 1.1 簡介 Spring是分層的Java SE/EE應用 full-stack輕量級開源框架，以IoC（Inverse Of Control

Spring aop學習整理(spring in action)（一）：了解AOP

進入 一起 table return 問題 匹配 核心 before cti 　　切面能幫助我們模塊化橫切關註點。簡而言之，橫切關註點可以被描述為影響應用多處的功能。例如，安全就是一個橫切關註點，應用中的許多方法都會涉及到安全規則。圖4.1直觀呈現了橫切關註點的概念。　　

Spring-Boot學習（一）

圖片 public ram turn tps bind 實現 file clas 入門實例 - HelloWorld File > New > Spring Starter Project 項目創建完成： 這樣就完成了項目的創建，下面我們

spring boot2 整合（一）Mybatis （特別完整！）

one OS solver mapper ant gin enabled selectall pom 大概介紹下流程： 借助idea實現mybatis逆向工程 用xml配置實現整合 用cmd命令行實現mybatis逆向工程 用mapping.xml配置實現數據交互

Spring Cloud OAuth2（一） 搭建授權服務

tde csr pub 賬號密碼 mailto 默認 HA zab acc 概要 本文內容主要為spring cloud 授權服務的搭建，采用jwt認證。 GitHub 地址：https://github.com/fp2952/spring-cloud-base/tree/

Spring MVC入門（一）—— SpringMVC的執行流程與常用註解

default 部分 它的 屬於 分享圖片 控制 mce AD http 一、什麽是SpringMVC SpringMVC就是類似於Struts2的mvc框架，屬於SpringFrameWork的後續產品。在模型層中與視圖層的交互部分。 springMVC執行流程：