2. 程式人生 > >spring技術體系學習筆記

spring技術體系學習筆記

阿新 • • 發佈：2018-11-11

目錄

1.spring簡介

2.spring入門案例

3.bean的生命週期

4.xml實現bean的裝配

5.註解實現bean的裝配

6.spring整合junit

7.代理

8.Aop

1.spring簡介

1.1 什麼是spring？

  1. spring產生於2003年，輕量級javase/ee一站式（表示層、業務邏輯層、資料持久層）開源框架。
  2. ejb：javabean包含私有屬性，公開的訪問器，以及無參構造；
  3. spring的官網：http://spring.io/

1.2 spring在3層架構中的地位？

  1. 表示層：SpringMVC/struts2
  2. 業務邏輯層：Spring Framework，注意區分當前講的spring是整個spring的體系結構包含Spring Framework。
  3. 資料持久層：Mybatis/Hibernate

1.3 spring的產生背景？點選檢視spring產生的背景，創始人堪稱大師級人物，學習的榜樣

1.4 spring的優點？

  1. 方便解耦，簡化開發：spring是工廠，負責建立物件以及物件關係維護。
  2. 支援aop程式設計（面向切面程式設計）
  3. sprint支援對優秀框架的整合（mybatis，struts2...）
  4. spring支援對javaee api的簡化
  5. spring支援對junit的整合

1.5 spring的體系結構？

1.6 spring的核心？IOC和AOP

什麼是Ioc？Inversion of Control，即“控制反轉”，不是什麼技術，而是一種設計思想。在Java開發中，Ioc意味著將物件建立和依賴的管理許可權反轉給spring容器。DI，即Dependency Injection，依賴注入。

什麼是AOP？面向切面程式設計，通過預編譯方式和執行期動態代理實現程式功能的統一維護的一種技術。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程式的可重用性，同時提高了開發的效率。

2.spring入門案例

案例：

  1. UserService介面和UserServiceImpl實現類模擬業務邏輯層
  2. UserDao介面和UserDaoImpl實現類模擬資料持久化層
  3. 初步使用spring

步驟：

  1. 建立Java專案，匯入jar包：4個核心jar包+commons-logging（日誌增強，mybatis/lib目錄下有）
    1. spring-beans-4.1.6.RELEASE.jar
    2. spring-context-4.1.6.RELEASE.jar
    3. spring-core-4.1.6.RELEASE.jar
    4. spring-expression-4.1.6.RELEASE.jar
    5. commons-logging-1.2.jar
  2. 編寫介面+實現類
  3. 在src目錄下建立並編寫配置檔案applicationContext.xml
  4. 獲取配置資訊並執行程式

程式碼：

介面及實現類

package dao;
public interface UserDao {
	void addUser();
	void deleteUser();
}

package dao.impl;
import dao.UserDao;
public class UserDaoImpl implements UserDao {
	@Override
	public void addUser() {
		System.out.println("新增使用者");
	}
	@Override
	public void deleteUser() {
		System.out.println("刪除使用者");
	}
}


package service;
public interface UserService {
	void addUser();
	void deleteUser();
}

package service.impl;
import dao.UserDao;
import service.UserService;
public class UserServiceImpl implements UserService {
	//介面引用+構造器
	//介面引用+setter方法
	private UserDao dao;
	public void setDao(UserDao dao){
		this.dao = dao;
	}
	public UserServiceImpl(UserDao dao){
		this.dao = dao;
	}
	@Override
	public void addUser() {
		dao.addUser();
	}
	@Override
	public void deleteUser() {
		dao.deleteUser();
	}
}

配置檔案：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:代表配置管理一個物件     id:唯一表示   class:類的完全限定名稱-->
	<bean id="userdao" class="dao.impl.UserDaoImpl"></bean>
	<!-- 呼叫無參構造+setter方法建立物件 -->
	<!-- <bean id="userservice" class="service.impl.UserServiceImpl">
		給屬性賦值 name:屬性名稱  value:賦值簡單型別 ref:引用型別賦值，使用容器中以後的bean物件userdao
		<property name="dao" ref="userdao"></property>
	</bean> -->
	<!-- 使用有參構造建立物件 -->
	<bean id="userservice" class="service.impl.UserServiceImpl">
		<!-- 構造引數：name:引數名稱 value:簡單型別賦值 ref:引用型別賦值 index:引數索引 type:引數型別-->
		<!-- <constructor-arg name="dao" ref="userdao" index="" type=""></constructor-arg> -->
		<constructor-arg index="0" ref="userdao" ></constructor-arg>
	</bean>
</beans>

讀取配置資訊並執行程式

package test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserService;
public class Test {
	public static void main(String[] args) {
		//建立管理物件的許可權都是開發者的
		//spring容器先建立和管理dao物件（配置檔案來實現）
		//從spring容器中獲取dao物件
		/*ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserDao dao = ac.getBean("userdao",UserDao.class);
		dao.addUser();
		dao.deleteUser();*/
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserService userservice = ac.getBean("userservice", UserService.class);
		userservice.addUser();
		userservice.deleteUser();
	}
}

3.bean的生命週期

bean生命週期圖示（關鍵階段用紅框標記，下面逐個解釋。）

BeanPostProcessors（Pre-initialization 和 Post-initialization）：

  1. 有時希望咱Spring IoC容器初始化受管Bean前、屬性設定後對該Bean先做一些預處理，或者在容器銷燬受管Bean之前釋放自己的資源。
  2. Spring IoC提供了多種方法來實現受管Bean的預處理和後處理。
  3. Spring中定義了BeanPostProcessors介面（如下方程式碼）。
  4. 若這個介面的某個實現類被註冊到容器，那麼該容器的每個受管Bean在呼叫初始化方法前，都會獲得該介面實現類的一個回撥。
  5. 容器呼叫介面定義的方法時會將該受管Bean的例項和名字通過引數傳入方法，經過處理後通過方法的返回值返回給容器。
  6. 使用ApplicationContext容器會在配置檔案自動尋找實現了BeanPostProcessor介面的bean，然後自動註冊。
package org.springframework.beans.factory.config;
import org.springframework.beans.BeansException;
public interface BeanPostProcessor {
	Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
	Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

Call custom init-method 和 Call custom destory-method：呼叫物件自定義初始化方法和自定義銷燬方法。使用步驟如下：

  1. 在User類中定義init()和destory()方法
  2. 在applicationContext.xml配置檔案中註冊User，程式碼<bean id="user" class="pojo.User" init-method="init" destory-method="destory"></bean>
  3. 獲取註冊bean，則自動呼叫init()方法，關閉容器則自動呼叫destory()方法
  4. 關閉容器的程式碼：ac.getClasss().getMethod("close").invoke(ac);//ac就是ApplicationContext物件

Bean is Ready To Use / Container is Shutdown：表示物件以準備好可以使用 / 表示關閉spring容器

4.註解實現bean的裝配

常用註解：

  • @Component：建立物件，等價於<bean class=" "></bean>
  • @Component("id")：建立物件，等價於<bean id=" " class=" "></bean>
  • @Controller：用於表示層建立物件（主要是為了區分，其實都可以通用）
  • @Service：用於業務邏輯層建立物件
  • @Repository：用於資料持久層用於建立物件
  • @Autowired：按照型別自動注入（找不到：不注入；找到1個：注入；找到多個：異常）
  • 按照名稱注入：
    • @Autowird 和 @Qualifiler("name")
    • @Resource(name="name")

使用步驟：

  1. 建立Java專案，匯入jar包
    1. spring 4+1（5個包）

    2. spring-aop.jar

  2. 分包：dao和dao.impl，service和service.impl
  3. 編寫介面及實現類並註解實現類
  4. 編寫applicationContext.xml配置檔案：掃描註解並建立物件
  5. 讀取配置並執行

示例程式碼：

dao和service包或子包中的程式碼

package dao;
public interface UserDao {
	void addUser();
	void deleteUser();
}

package dao.impl;
import org.springframework.stereotype.Repository;
import dao.UserDao;
//資料持久層建立物件的註解，userdao是所建立物件的名字
//建立物件需要：全限定類名+物件名（可選）
@Repository("userdao")
public class UserDaoImpl implements UserDao {
	@Override
	public void addUser() {
		System.out.println("新增使用者");
	}
	@Override
	public void deleteUser() {
		System.out.println("刪除使用者");
	}
}

package service;
public interface Service {
	void addUser();
	void deleteUser();
}

package service.impl;
import org.springframework.beans.factory.annotation.Autowired;
import dao.UserDao;
import service.Service;
//資料持久層建立物件的註解，service是所建立物件的名字
//這裡Service註解名和Service介面名衝突了
//建立物件需要：全限定類名+物件名（可選）
@org.springframework.stereotype.Service("service")
public class ServiceImpl implements Service {
	//按照型別自動注入，注入前提是spring Ioc容器中有該型別的物件
	//找不到物件：則不注入；找到1個物件：則自動注入；找到多個物件：則報異常
	@Autowired
	private UserDao dao;
	@Override
	public void addUser() {
		dao.addUser();
	}
	@Override
	public void deleteUser() {
		dao.deleteUser();
	}
}

spring配置檔案applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 引入了context的名稱空間，以及標籤庫 -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 掃描指定包中的註解，才能建立物件並注入依賴，這裡的包是基包，也就是說子包中的類也會被掃描 -->    
	<context:component-scan base-package="dao,service"></context:component-scan>
</beans>

Test測試類

package test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.Service;
public class Test {
	public static void main(String[] args) {
		//建立spring的ApplicationContext物件
		ApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");
		//獲取bean物件：第一個引數指定Ioc容器中的物件名，第二個引數指定物件型別
		Service service = application.getBean("service", Service.class);
		service.addUser();
		service.deleteUser();
	}
}

5.spring整合junit

什麼是junit？用於單元測試

如何使用junit？

  1. 匯入jar包：Eclipse IDE自帶，右鍵單擊專案名稱，選擇build path，再選擇add Libary，最後選擇Junit即可
  2. 編寫test()方法：在方法上方加上@Test註解，方法不能有返回值，不能有引數
  3. 執行test()方法：滑鼠游標放置在方法名稱，然後右鍵單擊，選擇run as，最後選擇JUnit Test執行

常用Junit註解：

  • @Test：註解方法，表示測試單元
  • @Before：在單獨執行單元前執行
  • @After：在單獨執行單元后執行
  • 示例程式碼：
package test;
import org.junit.After;
import org.junit.Before;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.Service;
public class Test {
	@Before
	public void before(){
		System.out.println("before");
	}
	@After
	public void after(){
		System.out.println("after");
	}
	@org.junit.Test
	public void testService(){
		//建立spring的ApplicationContext物件
		ApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");
		//獲取bean物件：第一個引數指定Ioc容器中的物件名，第二個引數指定物件型別
		Service service = application.getBean("service", Service.class);
		service.addUser();
		service.deleteUser();
	}
}

斷言Assert：

  • 在執行之前推斷程式碼的執行結果，如果推斷正確，則正常執行；若推斷錯誤，則執行失敗。
  • 示例程式碼：
package test;
import org.junit.Assert;
public class Test {
	@org.junit.Test
	public void test(){
		Assert.assertEquals("aa","aa");
	}
}

spring整合junit：

匯入jar：spring-test.jar

示例程式碼：在前面註解注入程式碼的基礎上修改如下

將test包加入掃描

<?xml version="1.0" encoding="UTF-8"?>
<!-- 引入了context的名稱空間，以及標籤庫 -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 掃描指定包中的註解，才能建立物件並注入依賴，這裡的包是基包，也就是說子包中的類也會被掃描 -->    
	<context:component-scan base-package="dao,service,test"></context:component-scan>
</beans>
package test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import service.Service;
//設定執行器
@RunWith(SpringJUnit4ClassRunner.class)
//獲取spring配置資訊
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class Test {
	//自動依賴注入
	@Autowired
	private Service service;
	@org.junit.Test
	public void test(){
		service.addUser();
		service.deleteUser();
	}
}

6.代理

代理定義：物件訪問前後實現預處理、過濾處理。比如在不改變原有增刪改查程式碼的情況下，新增事務

代理分類：靜態代理和動態代理

靜態代理：

  1. 編譯期間為每個委託類建立代理類
  2. 代理類與委託類實現同一個介面
  3. 示例程式碼：
//介面
package service;
public interface UserService {
	void addUser();
	void deleteUser();
}

package service.impl;
import service.UserService;
/**
 * 委託類
 */
public class UserServiceImpl implements UserService {
	@Override
	public void addUser() {
		System.out.println("新增使用者");
	}
	@Override
	public void deleteUser() {
		System.out.println("刪除使用者");
	}
}

package service.proxy;
import service.UserService;
import service.impl.UserServiceImpl;
/**
 * 代理類
 * 注意：代理類和委託類實現同一個介面
 */
public class UserServiceProxy implements UserService {
	UserService service = new UserServiceImpl();
	@Override
	public void addUser() {
		System.out.println("開啟事務");
		service.addUser();
		System.out.println("提交事務");
	}
	@Override
	public void deleteUser() {
		System.out.println("開啟事務");
		service.deleteUser();
		System.out.println("提交事務");
	}
}

package test;
import service.UserService;
import service.proxy.UserServiceProxy;
public class Test {
	@org.junit.Test
	public void testServiceProxy(){
		UserService service = new UserServiceProxy();
		service.addUser();
		service.deleteUser();
	}
}

動態代理：

  1. 執行期間為每個委託類的物件建立代理物件。兩種方式，如下
  2. 介面+委託類（不需要實現類了），執行的時候直接建立代理物件
  3. 示例程式碼：
package service;
public interface UserService {
	void addUser();
	void deleteUser();
}

package service.impl;
import service.UserService;
/**
 * 委託類
 */
public class UserServiceImpl implements UserService {
	@Override
	public void addUser() {
		System.out.println("新增使用者");
	}
	@Override
	public void deleteUser() {
		System.out.println("刪除使用者");
	}
}

package test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import service.UserService;
import service.impl.UserServiceImpl;
public class Test {
	//無侵入式增強
	@org.junit.Test
	public void testServiceProxy(){
		//1.建立委託類物件
		UserService service = new UserServiceImpl();
		//2.為委託類物件建立動態代理物件
		UserService proxy = (UserService) Proxy.newProxyInstance(
				service.getClass().getClassLoader(), 
				service.getClass().getInterfaces(), 
				new InvocationHandler() {
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) 
							throws Throwable {
						System.out.println("開啟事務");
						//手動呼叫方法
						Object obj = method.invoke(service, args);
						System.out.println("提交事務");
						return obj;
					}
				});
		//3.呼叫代理物件
		proxy.addUser();
		proxy.deleteUser();
	}
}

7.aop

什麼是aop？

  • 面向切面程式設計；
  • 採用橫向抽取的方式，在執行階段將增強程式碼織入目標物件的一種思想；
  • 底層採用的是動態代理。

什麼是橫向抽取？http://www.bubuko.com/infodetail-2060817.html

aop應用場景有哪些？事務管理，日誌系統，效能監測等。

aop框架有哪些？

  1. spring aop（spring-aop.jar）
  2. aspectj（aspecty.jar）
  3. jboss

aop的專業術語：

  1. target：目標物件。
  2. advice：通知，增強程式碼（遵循特定規範的增強程式碼）。
  3. joinpoint：連線點，即目標物件的方法。
  4. pointcut：切入點，真正新增增強程式碼的目標物件的方法。
  5. weaver：織入，增強程式碼新增到切入點的過程。
  6. aspect：切面，增強程式碼和切入點連線形成的邏輯面。

8.5 aop程式設計

配置方式實現：

  1. 建立Java專案並匯入jar包：
    1. 4+1：前面專案的jar包
    2. spring-aop.jar：aop框架
    3. aspects.jar：aspectj規範
    4. aopalliance-1.0.jar：aop聯盟（規範通知）
    5. aspectjweaver-1.8.5.jar：實現織入
  2. 編寫目標類
  3. 編寫增強類
  4. 編寫applicationContext.xml配置檔案
    1. 引人aop名稱空間及其標籤庫
    2. 建立目標類物件
    3. 建立增強類物件
    4. 織入
      1. 配置切入點
      2. 配置切面：呼叫前增強和呼叫後增強
  5. 單元測試
    1. @ContextConfiguration("classpath:applicationContext.xml")
    2. @runtime(SpringJUnit4ClassRunner.class)
    3. @Autowired自動注入依賴
  6. 程式碼如下：

 

package service;
public interface UserService {
	void addUser();
	void deleteUser();
}

package service.impl;
import service.UserService;
public class UserServiceImpl implements UserService {
	@Override
	public void addUser() {
		System.out.println("新增使用者");
	}
	@Override
	public void deleteUser() {
		System.out.println("刪除使用者");
	}
}

package aspect;
public class MyAspect {
	public void before(){
		System.out.println("開啟事務");
	}
	public void after(){
		System.out.println("提交事務");
	}
}

package test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import service.UserService;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Main {
	@Autowired
	private UserService service;
	@Test
	public void test(){
		service.addUser();
		service.deleteUser();
	}
}

 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:aop="http://www.springframework.org/schema/aop"
    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">
	<!-- 建立目標類物件 -->
	<bean id="userservice" class="service.impl.UserServiceImpl"></bean>
	<!-- 建立增強類物件 -->
	<bean id="myaspect" class="aspect.MyAspect"></bean>
	<!-- 織入 -->
	<aop:config>
		<!-- 配置切入點 -->
		<aop:pointcut expression="execution(* service..*(..))" id="mypoiontcut"/>
		<!-- 配置切面 -->
		<aop:aspect ref="myaspect">
			<aop:before method="before" pointcut-ref="mypoiontcut"/>
			<aop:after-returning method="after" pointcut-ref="mypoiontcut"/>
		</aop:aspect>
	</aop:config>
</beans>

註解方式實現：

  1. 建立Java專案並匯入jar包：
    1. 4+1：前面專案的jar包
    2. spring-aop.jar：aop框架
    3. aspects.jar：aspectj規範
    4. aopalliance-1.0.jar：aop聯盟（規範通知）
    5. aspectjweaver-1.8.5.jar：實現織入
  2. 編寫目標類
    1. @Component("userservice")建立目標類物件
  3. 編寫增強類
    1. @Component("myaspect")建立增強類物件
    2. @Aspect建立切面
    3. @PointCut("execution(* service..*(..))")建立切入點
    4. @Before("pointCut()")呼叫前增強
    5. @AfterReturning("pointCut()")呼叫後增強
  4. 編寫applicationContext.xml配置檔案
    1. 引入context名稱空間及其標籤庫
    2. 引入aop名稱空間及其標籤庫
    3. 掃描上下文註解並建立物件
    4. 宣告自動代理
  5. 單元測試
    1. @ContextConfiguration("classpath:applicationContext.xml")
    2. @runtime(SpringJUnit4ClassRunner.class)
    3. @Autowired自動注入依賴
  6. 程式碼如下：
package service;
public interface UserService {
	void addUser();
	void deleteUser();
}

package service.impl;
import org.springframework.stereotype.Component;
import service.UserService;
@Component("userservice")
public class UserServiceImpl implements UserService {
	@Override
	public void addUser() {
		System.out.println("新增使用者");
	}
	@Override
	public void deleteUser() {
		System.out.println("刪除使用者");
	}
}

package aspect;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component("myaspect")
@Aspect
public class MyAspect {
	@Pointcut("execution(* service..*(..))")
	public void pointCut(){}
	
	@Before("pointCut()")
	public void before(){
		System.out.println("開啟事務");
	}
	@AfterReturning("pointCut()")
	public void after(){
		System.out.println("提交事務");
	}
}

package test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import service.UserService;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Main {
	
	@Autowired
	private UserService service;
	
	@Test
	public void test(){
		service.addUser();
		service.deleteUser();
	}
}

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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
	<context:component-scan base-package="aspect,service"></context:component-scan>
	<aop:aspectj-autoproxy/>
</beans>

 

相關推薦

spring技術體系學習筆記

目錄 1.spring簡介 2.spring入門案例 3.bean的生命週期 4.xml實現bean的裝配 5.註解實現bean的裝配 6.spring整合junit 7.代理 8.Aop 1.spring簡介 1.1 什麼是spring？

《Spring技術內幕》筆記-Spring的設計理念和總體架構

ace app flex nfa 使用 架構 非關系型數據庫 ack pri 1。Spring的主要子項目： ????-1。Spring Framework(Cor

Spring源碼學習筆記1

ror .... AD amr pen return 接口 throw final 1.Spring中最核心的兩個類 1)DefaultListableBeanFactory 　　XmlBeanFactory繼承自DefaultListableBeanFactory，Def

“阿裏巴巴大數據系統體系”學習筆記-綱領篇

同時 廣告 計算 業務需求 學習筆記 com 之一 離線 滿足 “你是做什麽的？” “數據產品經理”看到對方一臉懵逼之後，再補充一句“大數據相關的工作” “哦～，高大上，不懂” 過去5年，“大數據”是最火的一個概念，被紛繁解讀。在我看來，數據跟石油、煤炭一樣是一種資源。這種

MongoDB集群之分片技術應用 —— 學習筆記

並且 水平 副本 分享圖片 version linux 數量 ready 應用 課程鏈接：https://www.imooc.com/learn/501 一、什麽是分片？ 分片：將數據進行2拆分，將數據水平的分散到不同的服務器上。 二、為什麽要分片？ 架構上：讀寫均衡、

Spring Boot2.0學習筆記（一）

target uil pom true framework build 項目 組件 文件 1、Spring Boot項目啟動方式 （1）主程序啟動 @SpringBootApplication public class HelloApplication { pu

spring分散式事務學習筆記（2）

此文已由作者夏昀授權網易雲社群釋出。 歡迎訪問網易雲社群，瞭解更多網易技術產品運營經驗。 Model類如下：package com.xy.model 1 package com.xy.model;  2   3 /**  

Spring Boot Validator 學習筆記

Spring Boot Validator 筆記 1 背景 開發過程中，後臺的引數校驗是必不可少的，本文關於 spring-boot-starter-validation的學習筆記 2 示例 2.1 如何在pom.xml中引用 <?xml version="1.

《計算機韌體安全技術》學習筆記

[本文所有內容均來自於對周振柳博士出版的《計算機韌體安全技術》一書的摘抄、引用和歸納，如有侵權，請聯絡刪除] 1.引言 1.1 韌體和BIOS概念 1.1.1 概念 計算機韌體是計算機系統中不可缺少的底層基礎系統，往往以軟體形式固化儲存在硬體晶片中。 BIO

Spring Cloud Eureka學習筆記

用於服務的註冊於發現 由兩個元件組成 Eureka Server 註冊中心 Eureka Client 服務註冊 Eureka Server(服務註冊中心) 先建立一個springboot專案，新增依賴的時候選擇如下 pom檔案如下 <?xml ve

JavaEE開發的顛覆者：Spring Boot實戰 學習筆記4--Spring高階話題

SpringAware  可呼叫Spring所提供的資源  多執行緒 配置類 /** * 多執行緒和併發程式設計 */ @Configuration @ComponentScan("com.wisely.highlight_spring4_idea.ch3.t

spring分散式事務學習筆記（1）

此文已由作者夏昀授權網易雲社群釋出。 歡迎訪問網易雲社群，瞭解更多網易技術產品運營經驗。 分散式事務對效能有一定的影響，所以不是最佳的解決方案，能通過設計避免最好儘量避免。 分散式事務（Distributed transactions），也稱作XA事務(XA是一個協議的名字)，在spring中被稱作glob

《Spring實戰》學習筆記-第八章：使用Spring Web Flow

第四版的第八章內容與第三版基本一致。 本章內容： 建立會話式web應用程式 定義流程狀態和行為 保護web流程 網際網路的一個奇特之處就在於它很容易讓人迷失。有如此多的內容可以檢視和閱讀，而超連結是其強大魔力的核心所在。 有時候，web應用程式需要控

Spring MVC的學習筆記

基於註解形式配置Spring MVC 一、註冊並初始化DispatcherServlet，由Servlet容器自動檢測並啟動 註解形式 public class MyWebApplicationInitializer implements WebApplicationInitializer {

《資料探勘概念與技術》學習筆記

1.Chapter1 引論： (1) OLTP 和 OLAP 概念: OLTP(on-line transaction processing) 聯機事物處理，就是我們經常說的關係資料庫的主要應用，主要是基本的、日常的事務處理，例如銀行交易。例如：mysql OLAP(on

Spring-Data-JPA 學習筆記(一)

作者：zeng1994 一、spring-data-jpa的簡單介紹 SpringData : Spring 的一個子專案。用於簡化資料庫訪問，支援NoSQL 和 關係資料儲存。其主要目標是使資料庫的訪問變得方便快捷。 SpringData

postgresql 技術內幕學習筆記

本文原文地址（讀了兩篇文章的重點筆記）： PostgreSQL查詢優化器詳解之邏輯優化篇 PostgreSQL查詢優化器詳解之物理優化篇 第一章 概述 1.1 查詢優化的簡介 一個查詢優化器它的輸入是查詢樹，輸出是查詢執行計劃 。 通常資料庫的查詢優化分為兩個層次：

【資料探勘概念與技術】學習筆記6-挖掘頻繁模式、關聯和相關性：基本概念和方法（編緝中）

頻繁模式是頻繁地出現在資料集中的模式（如項集、子序列或子結構）。頻繁模式挖掘給定資料集中反覆出現的聯絡。“購物籃”例子，想象全域是商店中商品的集合，每種商品有一個布林變數，表示該商品是否出現。則每個購物籃可以用一個布林向量表示。分析布林向量，得到反映商品頻繁關聯或同時購買的購買模式。這些模式可用關聯規則來表示

《Spring技術內幕》筆記-第二章 IoC容器的實現

簡介 1，在Spring中，SpringIoC提供了一個基本的JavaBean容器，通過IoC模式管理依賴關係，並通過依賴注入和AOP切面增強了為JavaBean這樣子的POJO提供事務管理，生命週期管理等功能。 2，Spring IoC的設計中，主要包含兩個主要的容

spring配置檔案學習筆記

<!-- 整篇系列內容都是根據郭峰大大的Spring從入門到精通學習整理的--> SPRING配置檔案詳解 概念、用途： Spring配置檔案是用於指導spring工廠進行bean生產、依賴注入(裝配)及Bean例項分發的”圖紙”。 Spring配置檔案是一個