【轉】Java面試題全集2.2（上）

時間 2019-11-24

標籤 java 面試 2.2 欄目 Java 简体版

原文原文鏈接

14六、什麼是IoC和DI？DI是如何實現的？

答：IoC叫控制反轉，是Inversion of Control的縮寫，DI（Dependency Injection）叫依賴注入，是對IoC更簡單的詮釋。控制反轉是把傳統上由程序代碼直接操控的對象的調用權交給容器，經過容器來實現對象組件的裝配和管理。所謂的」控制反轉」就是對組件對象控制權的轉移，從程序代碼自己轉移到了外部容器，由容器來建立對象並管理對象之間的依賴關係。IoC體現了好萊塢原則 – 「Don’t call me, we will call you」。依賴注入的基本原則是應用組件不該該負責查找資源或者其餘依賴的協做對象。配置對象的工做應該由容器負責，查找資源的邏輯應該從應用組件的代碼中抽取出來，交給容器來完成。DI是對IoC更準確的描述，即組件之間的依賴關係由容器在運行期決定，形象的來講，即由容器動態的將某種依賴關係注入到組件之中。html

舉個例子：一個類A須要用到接口B中的方法，那麼就須要爲類A和接口B創建關聯或依賴關係，最原始的方法是在類A中建立一個接口B的實現類C的實例，但這種方法須要開發人員自行維護兩者的依賴關係，也就是說當依賴關係發生變更的時候須要修改代碼並從新構建整個系統。若是經過一個容器來管理這些對象以及對象的依賴關係，則只須要在類A中定義好用於關聯接口B的方法（構造器或setter方法），將類A和接口B的實現類C放入容器中，經過對容器的配置來實現兩者的關聯。java

依賴注入能夠經過setter方法注入（設值注入）、構造器注入和接口注入三種方式來實現，Spring支持setter注入和構造器注入，一般使用構造器注入來注入必須的依賴關係，對於可選的依賴關係，則setter注入是更好的選擇，setter注入須要類提供無參構造器或者無參的靜態工廠方法來建立對象。程序員

14七、Spring中Bean的做用域有哪些？spring

答：在Spring的早期版本中，僅有兩個做用域：singleton和prototype，前者表示Bean以單例的方式存在；後者表示每次從容器中調用Bean時，都會返回一個新的實例，prototype一般翻譯爲原型。sql

補充：設計模式中的建立型模式中也有一個原型模式，原型模式也是一個經常使用的模式，例如作一個室內設計軟件，全部的素材都在工具箱中，而每次從工具箱中取出的都是素材對象的一個原型，能夠經過對象克隆來實現原型模式。數據庫

Spring 2.x中針對WebApplicationContext新增了3個做用域，分別是：request（每次HTTP請求都會建立一個新的Bean）、session（同一個HttpSession共享同一個Bean，不一樣的HttpSession使用不一樣的Bean）和globalSession（同一個全局Session共享一個Bean）。apache

說明：單例模式和原型模式都是重要的設計模式。通常狀況下，無狀態或狀態不可變的類適合使用單例模式。在傳統開發中，因爲DAO持有Connection這個非線程安全對象於是沒有使用單例模式；但在Spring環境下，全部DAO類對能夠採用單例模式，由於Spring利用AOP和Java API中的ThreadLocal對非線程安全的對象進行了特殊處理。編程

ThreadLocal爲解決多線程程序的併發問題提供了一種新的思路。ThreadLocal，顧名思義是線程的一個本地化對象，當工做於多線程中的對象使用ThreadLocal維護變量時，ThreadLocal爲每一個使用該變量的線程分配一個獨立的變量副本，因此每個線程均可以獨立的改變本身的副本，而不影響其餘線程所對應的副本。從線程的角度看，這個變量就像是線程的本地變量。設計模式

ThreadLocal類很是簡單好用，只有四個方法，能用上的也就是下面三個方法：安全

- void set(T value)：設置當前線程的線程局部變量的值。

- T get()：得到當前線程所對應的線程局部變量的值。

- void remove()：刪除當前線程中線程局部變量的值。

ThreadLocal是如何作到爲每個線程維護一份獨立的變量副本的呢？在ThreadLocal類中有一個Map，鍵爲線程對象，值是其線程對應的變量的副本，本身要模擬實現一個ThreadLocal類其實並不困難，代碼以下所示：

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

public class MyThreadLocal<T> {

private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>());

public void set(T newValue) {

map.put(Thread.currentThread(), newValue);

}

public T get() {

return map.get(Thread.currentThread());

}

public void remove() {

map.remove(Thread.currentThread());

}

}

14八、解釋一下什麼叫AOP（面向切面編程）？

答：AOP（Aspect-Oriented Programming）指一種程序設計範型，該範型以一種稱爲切面（aspect）的語言構造爲基礎，切面是一種新的模塊化機制，用來描述分散在對象、類或方法中的橫切關注點（crosscutting concern）。

14九、你是如何理解」橫切關注」這個概念的？

答：」橫切關注」是會影響到整個應用程序的關注功能，它跟正常的業務邏輯是正交的，沒有必然的聯繫，可是幾乎全部的業務邏輯都會涉及到這些關注功能。一般，事務、日誌、安全性等關注就是應用中的橫切關注功能。

150、你如何理解AOP中的鏈接點（Joinpoint）、切點（Pointcut）、加強（Advice）、引介（Introduction）、織入（Weaving）、切面（Aspect）這些概念？

答：

a. 鏈接點（Joinpoint）：程序執行的某個特定位置（如：某個方法調用前、調用後，方法拋出異常後）。一個類或一段程序代碼擁有一些具備邊界性質的特定點，這些代碼中的特定點就是鏈接點。Spring僅支持方法的鏈接點。

b. 切點（Pointcut）：若是鏈接點至關於數據中的記錄，那麼切點至關於查詢條件，一個切點能夠匹配多個鏈接點。Spring AOP的規則解析引擎負責解析切點所設定的查詢條件，找到對應的鏈接點。

c. 加強（Advice）：加強是織入到目標類鏈接點上的一段程序代碼。Spring提供的加強接口都是帶方位名的，如：BeforeAdvice、AfterReturningAdvice、ThrowsAdvice等。不少資料上將加強譯爲「通知」，這明顯是個詞不達意的翻譯，讓不少程序員困惑了許久。

說明： Advice在國內的不少書面資料中都被翻譯成」通知」，可是很顯然這個翻譯沒法表達其本質，有少許的讀物上將這個詞翻譯爲」加強」，這個翻譯是對Advice較爲準確的詮釋，咱們經過AOP將橫切關注功能加到原有的業務邏輯上，這就是對原有業務邏輯的一種加強，這種加強能夠是前置加強、後置加強、返回後加強、拋異常時加強和包圍型加強。

d. 引介（Introduction）：引介是一種特殊的加強，它爲類添加一些屬性和方法。這樣，即便一個業務類本來沒有實現某個接口，經過引介功能，能夠動態的未該業務類添加接口的實現邏輯，讓業務類成爲這個接口的實現類。

e. 織入（Weaving）：織入是將加強添加到目標類具體鏈接點上的過程，AOP有三種織入方式：①編譯期織入：須要特殊的Java編譯期（例如AspectJ的ajc）；②裝載期織入：要求使用特殊的類加載器，在裝載類的時候對類進行加強；③運行時織入：在運行時爲目標類生成代理實現加強。Spring採用了動態代理的方式實現了運行時織入，而AspectJ採用了編譯期織入和裝載期織入的方式。

f. 切面（Aspect）：切面是由切點和加強（引介）組成的，它包括了對橫切關注功能的定義，也包括了對鏈接點的定義。

補充：代理模式是GoF提出的23種設計模式中最爲經典的模式之一，代理模式是對象的結構模式，它給某一個對象提供一個代理對象，並由代理對象控制對原對象的引用。簡單的說，代理對象能夠完成比原對象更多的職責，當須要爲原對象添加橫切關注功能時，就可使用原對象的代理對象。咱們在打開Office系列的Word文檔時，若是文檔中有插圖，當文檔剛加載時，文檔中的插圖都只是一個虛框佔位符，等用戶真正翻到某頁要查看該圖片時，纔會真正加載這張圖，這其實就是對代理模式的使用，代替真正圖片的虛框就是一個虛擬代理；Hibernate的load方法也是返回一個虛擬代理對象，等用戶真正須要訪問對象的屬性時，才向數據庫發出SQL語句得到真實對象。

下面用一個找槍手代考的例子演示代理模式的使用：

/**

* 參考人員接口

* @author 駱昊

*

*/

public interface Candidate {

/**

* 答題

*/

public void answerTheQuestions();

}

/**

* 懶學生

* @author 駱昊

*

*/

public class LazyStudent implements Candidate {

private String name; // 姓名

public LazyStudent(String name) {

this.name = name;

}

@Override

public void answerTheQuestions() {

// 懶學生只能寫出本身的名字不會答題

System.out.println("姓名: " + name);

}

}

/**

* 槍手

* @author 駱昊

*

*/

public class Gunman implements Candidate {

private Candidate target; // 被代理對象

public Gunman(Candidate target) {

this.target = target;

}

@Override

public void answerTheQuestions() {

// 槍手要寫上代考的學生的姓名

target.answerTheQuestions();

// 槍手要幫助懶學生答題並交卷

System.out.println("奮筆疾書正確答案");

System.out.println("交卷");

}

}

public class ProxyTest1 {

public static void main(String[] args) {

Candidate c = new Gunman(new LazyStudent("王小二"));

c.answerTheQuestions();

}

}

說明：從JDK 1.3開始，Java提供了動態代理技術，容許開發者在運行時建立接口的代理實例，主要包括Proxy類和InvocationHandler接口。下面的例子使用動態代理爲ArrayList編寫一個代理，在添加和刪除元素時，在控制檯打印添加或刪除的元素以及ArrayList的大小：

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.util.List;

public class ListProxy<T> implements InvocationHandler {

private List<T> target;

public ListProxy(List<T> target) {

this.target = target;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

Object retVal = null;

System.out.println("[" + method.getName() + ": " + args[0] + "]");

retVal = method.invoke(target, args);

System.out.println("[size=" + target.size() + "]");

return retVal;

}

}

import java.lang.reflect.Proxy;

import java.util.ArrayList;

import java.util.List;

public class ProxyTest2 {

@SuppressWarnings("unchecked")

public static void main(String[] args) {

List<String> list = new ArrayList<String>();

Class<?> clazz = list.getClass();

ListProxy<String> myProxy = new ListProxy<String>(list);

List<String> newList = (List<String>)

Proxy.newProxyInstance(clazz.getClassLoader(),

clazz.getInterfaces(), myProxy);

newList.add("apple");

newList.add("banana");

newList.add("orange");

newList.remove("banana");

}

}

說明：使用Java的動態代理有一個侷限性就是代理的類必需要實現接口，雖然面向接口編程是每一個優秀的Java程序都知道的規則，但現實每每不盡如人意，對於沒有實現接口的類如何爲其生成代理呢？繼承！繼承是最經典的擴展已有代碼能力的手段，雖然繼承經常被初學者濫用，但繼承也經常被進階的程序員忽視。CGLib採用很是底層的字節碼生成技術，經過爲一個類建立子類來生成代理，它彌補了Java動態代理的不足，所以Spring中動態代理和CGLib都是建立代理的重要手段，對於實現了接口的類就用動態代理爲其生成代理類，而沒有實現接口的類就用CGLib經過繼承的方式爲其建立代理。

15一、Spring中自動裝配的方式有哪些？

答：

- no：不進行自動裝配，手動設置Bean的依賴關係。

- byName：根據Bean的名字進行自動裝配。

- byType：根據Bean的類型進行自動裝配。

- constructor：相似於byType，不過是應用於構造器的參數，若是正好有一個Bean與構造器的參數類型相同則能夠自動裝配，不然會致使錯誤。

- autodetect：若是有默認的構造器，則經過constructor的方式進行自動裝配，不然使用byType的方式進行自動裝配。

說明：自動裝配沒有自定義裝配方式那麼精確，並且不能自動裝配簡單屬性（基本類型、字符串等），在使用時應注意。

15二、Spring中如何使用註解來配置Bean？有哪些相關的註解？

答：首先須要在Spring配置文件中增長以下配置：

<context:component-scan base-package="org.example"/>

而後能夠用@Component、@Controller、@Service、@Repository註解來標註須要由Spring IoC容器進行對象託管的類。這幾個註解沒有本質區別，只不過@Controller一般用於控制器，@Service一般用於業務邏輯類，@Repository一般用於倉儲類（例如咱們的DAO實現類），普通的類用@Component來標註。

15三、Spring支持的事務管理類型有哪些？你在項目中使用哪一種方式？

答：Spring支持編程式事務管理和聲明式事務管理。許多Spring框架的用戶選擇聲明式事務管理，由於這種方式和應用程序的關聯較少，所以更加符合輕量級容器的概念。聲明式事務管理要優於編程式事務管理，儘管在靈活性方面它弱於編程式事務管理，由於編程式事務容許你經過代碼控制業務。

事務分爲全局事務和局部事務。全局事務由應用服務器管理，須要底層服務器JTA支持（如WebLogic、WildFly等）。局部事務和底層採用的持久化方案有關，例如使用JDBC進行持久化時，須要使用Connetion對象來操做事務；而採用Hibernate進行持久化時，須要使用Session對象來操做事務。

Spring提供了以下所示的事務管理器。

這些事務的父接口都是PlatformTransactionManager。Spring的事務管理機制是一種典型的策略模式，PlatformTransactionManager表明事務管理接口，該接口定義了三個方法，該接口並不知道底層如何管理事務，可是它的實現類必須提供getTransaction()方法（開啓事務）、commit()方法（提交事務）、rollback()方法（回滾事務）的多態實現，這樣就能夠用不一樣的實現類表明不一樣的事務管理策略。使用JTA全局事務策略時，須要底層應用服務器支持，而不一樣的應用服務器所提供的JTA全局事務可能存在細節上的差別，所以實際配置全局事務管理器是可能須要使用JtaTransactionManager的子類，如：WebLogicJtaTransactionManager（Oracle的WebLogic服務器提供）、UowJtaTransactionManager（IBM的WebSphere服務器提供）等。

編程式事務管理以下所示。

<?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"

xmlns:p="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="com.jackfrued"/>

<bean id="propertyConfig"

class="org.springframework.beans.factory.config.

PropertyPlaceholderConfigurer">

<property name="location">

<value>jdbc.properties</value>

</property>

</bean>

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">

<property name="driverClassName">

<value>${db.driver}</value>

</property>

<property name="url">

<value>${db.url}</value>

</property>

<property name="username">

<value>${db.username}</value>

</property>

<property name="password">

<value>${db.password}</value>

</property>

</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

<property name="dataSource">

<ref bean="dataSource" />

</property>

</bean>



<bean id="transactionManager"

class="org.springframework.jdbc.datasource.

DataSourceTransactionManager"　scope="singleton">

<property name="dataSource">

<ref bean="dataSource" />

</property>

</bean>



<bean id="transactionTemplate"

class="org.springframework.transaction.support.

TransactionTemplate">

<property name="transactionManager">

<ref bean="transactionManager" />

</property>

</bean>

</beans>

package com.jackfrued.dao.impl;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.jdbc.core.JdbcTemplate;

import com.jackfrued.dao.EmpDao;

import com.jackfrued.entity.Emp;

@Repository

public class EmpDaoImpl implements EmpDao {

@Autowired

private JdbcTemplate jdbcTemplate;

@Override

public boolean save(Emp emp) {

String sql = "insert into emp values (?,?,?)";

return jdbcTemplate.update(sql, emp.getId(), emp.getName(), emp.getBirthday()) == 1;

}

}

package com.jackfrued.biz.impl;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.TransactionStatus;

import org.springframework.transaction.support.TransactionCallbackWithoutResult;

import org.springframework.transaction.support.TransactionTemplate;

import com.jackfrued.biz.EmpService;

import com.jackfrued.dao.EmpDao;

import com.jackfrued.entity.Emp;

@Service

public class EmpServiceImpl implements EmpService {

@Autowired

private TransactionTemplate txTemplate;

@Autowired

private EmpDao empDao;

@Override

public void addEmp(final Emp emp) {

txTemplate.execute(new TransactionCallbackWithoutResult() {

@Override

protected void doInTransactionWithoutResult(TransactionStatus txStatus) {

empDao.save(emp);

}

});

}

}