簡答題：

1.IOC容器：

IOC（Inversion of Control，控制反轉），這是spring的核心，
在這里插入圖片描述
IOC容器具有依賴注入功能的容器，IOC容器負責實體化、定位、配置應用程式中的物件及建立這些物件間的依賴，應用程式無需直接在代碼中new相關的物件，應用程式由IOC容器進行組裝，

2. 靜態代理

為什么需要代理？

因為我們可以在代理的時候做一些屬于我們自己的操作，
在這里插入圖片描述

3. 工廠模式

工廠模式專門負責將大量有共同介面的類實體化，工廠模式可以動態決定將哪一個類實體化，不必事先知道每次要實體化哪一個類，

在這里插入圖片描述

4. Servlet生命周期

Seevlet的生命周期由Servlet容器管理，（Tomcat是一種）

加載和實體化Servlet
初始化init()
執行sevice()處理請求
執行destroy()銷毀

假如我們在代碼里面把Service的方法改寫了，那么這個時候的service就不是用來轉向了，就是變成處理邏輯了，

5. Sevlet 時序圖

在這里插入圖片描述

6. 分層領域模型規約

一、分層領域模型規約
在這里插入圖片描述

DO（Data Object）：與資料庫表結構一一對應，通過DAO層向上傳輸資料源物件，
DTO（Data Transfer Object）：資料傳輸物件，Service或Manager向外傳輸的物件，
BO（Business Object）：業務物件，由Service層輸出的封裝業務邏輯的物件，
AO（Application Object）：應用物件，在Web層與Service層之間抽象的復用物件模型，極為貼近展示層，復用度不高，
VO（View Object）：顯示層物件，通常是Web向模板渲染引擎層傳輸的物件，
Query：資料查詢物件，各層接收上層的查詢請求，注意超過2個引數的查詢封裝，禁止使用Map類來傳輸，

二、領域模型命名規約

1）資料物件：xxxDO，xxx即為資料表名，
2）資料傳輸物件：xxxDTO，xxx為業務領域相關的名稱，
3）展示物件：xxxVO，xxx一般為網頁名稱，
4） POJO是DO/DTO/BO/VO的統稱，禁止命名成xxxPOJO，

7. 網路編程模型

8. MVC 框架

在這里插入圖片描述

虛線是事件，實作是方法呼叫
在這里插入圖片描述

視圖：JSP，HTML，XML（解釋模型，模型更新請求）
模型：bean，enity，VO，formbean（應用程式功能，封裝應用程式狀態）
控制器：Servlet，Spring（定義應用程式行為，映射用戶動作，選擇回應的視圖）

視圖和資料模型的分離：使用不同的視圖對相同的資料進行展示；分離可視和不可視的組件，能夠對模型進行獨立測驗，

視圖和表現邏輯(Controller)的分離：Controller是一個表現邏輯的組件，并非一個業務邏輯組件，MVC可以作為表現模式也可以作為建構模式，意味這Controller也可以是業務邏輯，分離邏輯和具體展示，能夠對邏輯進行獨立測驗，

優點：耦合性低；重用性高；生命周期成本低；部署快；可維護性高；有利軟體工程化管理，
缺點：沒有明確的定義；不適合小型，中等規模的應用程式；增加系統結構和實作的復用性；視圖與控制器間的過于緊密的連接；視圖對模型資料的低效率訪問；一般高級的界面工具或構造器不支持模式，

編程題

1. 多執行緒排序

import java.util.Arrays;
import java.util.concurrent.*;

//----App Class
public App() throws InterruptedException {
        int data[]={12,434,54,6,7,0,123,4,65,23,34,1,234242,324234,232,23,23425,52};

        ForkJoinTask sort = new SortWorker(data);
        ForkJoinPool pool = new ForkJoinPool();
        pool.submit(sort);
        pool.shutdown();
        
        pool.awaitTermination(30, TimeUnit.SECONDS);
        print(data);
    }
//----App Class

//----SortWorker
class SortWorker extends RecursiveAction{    
        private int[] data;
        private int start;
        private int end;

        private int THRESHOLD = 0;

        public SortWorker(int[] data){
            this.data = data;
            this.start = 0;
            this.end = data.length-1;
        }


        public SortWorker(int[] data, int start, int end){
            this.data = data;
            this.start = start;
            this.end = end;
        }

        private void swap(int[] data,int j,int j1){
            int temp = data[j];
            data[j] = data[j1];
            data[j1] = temp;
        }

        private void seqSort(int[] data, int start, int end){
            Arrays.sort(data, start, end+1);
        }

        private int partition(int[] data, int start, int end){
            int x = data[end];
            int i = start - 1;
            for(int j = start; j< end;j++){
                if (data[j]<=x){
                    i++;
                    swap(data, i, j);
                }
            }
            swap(data, i+1, end);
            return i+1;
        }

        protected void compute(){
            if (end - start < THRESHOLD){ 
                seqSort(data, start, end); //假如陣列長度小于閾值則直接排序
            }else{
                //否則則使用遞回拆分排序
                int pivot = partition(data, start, end);
                RecursiveAction.invokeAll(new SortWorker(data,start,pivot-1), new SortWorker(data, pivot+1, end));
            }
        }
    }

2. 多執行緒求最大值

//----App.class
    public App() throws InterruptedException {
        int data[]={12,434,54,6,7,0,123,4,65,23,34,1,234242,324234,232,23,23425,52};

        ForkJoinTask<Integer> findMax = new MaxWorker(data);
        ForkJoinPool pool = new ForkJoinPool(4);
        
        Integer re = pool.invoke(findMax);
        pool.shutdown();
        
        pool.awaitTermination(30, TimeUnit.SECONDS);
        System.out.println(re);
    }
//---

class MaxWorker extends RecursiveTask<Integer>{    
        private int[] data;
        private int start;
        private int end;

        private int THRESHOLD = 4; // 限制每個小任務的大小

        public MaxWorker(int[] data){
            this.data = data;
            this.start = 0;
            this.end = data.length;
        }


        public MaxWorker(int[] data, int start, int end){
            this.data = data;
            this.start = start;
            this.end = end;
        }

        private Integer seqFindMax(int[] data, int start, int end){
            int max = Integer.MIN_VALUE;
            for(int i = start; i< end ; i++){
                if(max<data[i]){
                    max = data[i];
                }
            }
            return max;
        }

        @Override
        protected Integer compute(){
            Integer result = null;
            if (end - start < THRESHOLD){ 
                result = seqFindMax(data, start, end); //假如陣列長度小于閾值則執行任務并且把結果回傳到上層
            }else{
                //否則則使用遞回拆分排序
                int middle = (start + end) / 2;
                MaxWorker left = new MaxWorker(data, start, middle);
                MaxWorker right = new MaxWorker(data, middle, end);
                // 拆分并并行執行兩個小任務
                left.fork();
                right.fork();

                result = Math.max(left.join(),right.join());
            }
            return result;
        }
    }

3. Web服務器：

Server.class

    @Override
    public void run() {
        super.run();
            @SuppressWarnings("resource") // Warnings iggnore
            ServerSocket serverSocket = new ServerSocket(watchPort);
            while (true) { // Waitting for clients
                Socket socket = serverSocket.accept();// Thread Join here
                new httpServer(socket).start();// If connected, start a new server thread
            }
    }

httpServer.class

    class httpServer extends Thread {

        Socket currentSocket = null; //Client Socket
        InputStream inputStream = null;//Use for get header
        OutputStream outputStream = null;//Use for response
        
        public httpServer(Socket socket) {
                currentSocket = socket; //Get socket bridge
                //log.info(socket.getInetAddress().toString()); //Show ip address
                inputStream = socket.getInputStream(); // Get inputstream
                outputStream = socket.getOutputStream(); // Get outputstream
        }

        @Override
        public void run() {
                String rawString = read(); // Get raw header
                String resultString = process(rawString); // Process command
                String rawResultString = response(resultString); // Pack the result
                currentSocket.close();// CLose the client socket
         }

read：

 				String[] split = rawString.split(" ");
                if (split.length != 3) { //@example as: GET /index.html HTTP/1.1
                    return null;
                }
                return split[1]; // Get path

process：

                File file = new File("src/"+commandString);
                fileReader = new FileReader(file);
                bufferedReader = new BufferedReader(fileReader);
                StringBuffer stringBuffer = new StringBuffer();
                String line;
                while((line = bufferedReader.readLine())!=null){
                    stringBuffer.append(line+"\r\n");
                }
                String result = stringBuffer.toString();

response：

               StringBuffer responseInfo = new StringBuffer();
               responseInfo.append("HTTP/1.1 200 ok \r\n");
               responseInfo.append("Content-Type:text/html \r\n");
               responseInfo.append("Content-Length:"+Long.toString(responseLength)+" \r\n\r\n");
               responseInfo.append(resultString);
               outputStream.write(rawResultString.getBytes());
               outputStream.flush();
               outputStream.close();

可能的客戶端：

Socket client = new Socket("localhost", 9999); // 定義服務端的連接資訊
// 現在的客戶端需要有輸入與輸出的操作支持，所以依然要準備出Scanner與PrintWriter
Scanner scan = new Scanner(client.getInputStream()); // 接收服務端輸入內容
scan.useDelimiter("\n");
PrintStream out = new PrintStream(client.getOutputStream()); // 向服務器端發送內容
boolean flag = true; // 回圈標記
while (flag) { // 回圈處理
		String input = getString("請輸入要發送的內容：").trim(); // 獲取鍵盤輸入資料
		out.println(input); // 加換行
	if (scan.hasNext()) { // 服務器端有回應
		System.out.println(scan.next()); // 輸出回應資訊
	}
	if ("byebye".equalsIgnoreCase(input)) { // 結束判斷
		flag = false; // 修改回圈標記
	}
}
scan.close(); // 關閉輸入流
out.close(); // 關閉輸 出流
client.close(); // 關閉客戶端

4. JSP+Servlet+JDBC

bean-DAO-Servlet-JSP

DAO：

    private static InitialContext context = null;
    private DataSource dataSource = null;
    if (context == null) {
                context = new InitialContext();
            }
   dataSource = (DataSource) context.lookup("java:comp/env/jdbc/bookDS");

執行邏輯：

        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rst = null;
        BookBean book = new BookBean();
        try {
            conn = dataSource.getConnection();
            //pstmt = conn.prepareStatement("INSERT INTO books VALUES(?,?,?,?,?)");
            pstmt = conn.prepareStatement("SELECT * FROM books WHERE bookid=?");
            pstmt.setString(1, bookid);
            rst = pstmt.executeQuery();
            if (rst.next()) {
                book.setBookid(rst.getString("bookid"));
                book.setTitle(rst.getString("title"));
                book.setAuthor(rst.getString("author"));
                book.setPublisher(rst.getString("publisher"));
                book.setPrice(rst.getFloat("price"));
                return book;
            } else {
                return null;
            }

Servlet：

public class BookInsertServlet extends HttpServlet {
    public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("gb2312");
        String message = null;
        BookBean book = new BookBean(request.getParameter("bookid"), request.getParameter("title"),
                request.getParameter("author"), request.getParameter("publisher"),
                Float.parseFloat(request.getParameter("price")));
        BookDAO bookdao = new BookDAO();
        boolean success = bookdao.insertBook(book);
        if (success) {
            message = "成功插入一條記錄！";
        } else {
            message = "插入記錄錯誤！";
        }
        request.setAttribute("result", message);
        
        RequestDispatcher view = request.getRequestDispatcher("/bookInsert.jsp");
        view.forward(request, response);
    }
}

JSP：

<%@ page contentType="text/html; charset=gb2312" %>
    <html>

    <head>
        <title>Book Query</title>
    </head>

    <body>
        請輸入一個書號:<br>
        <form action="bookquery.do" method="post">
            <input type="text" name="bookid"><br>
            <input type="submit" value="提交">
        </form>
    </body>
    </html>

Web.xml：

servlet

name
class

mapping

name
url-pattern

<servlet>
    <servlet-name>bookQuery</servlet-name>
    <servlet-class>com.control.BookQueryServlet</servlet-class>
</servlet>

<servlet>
    <servlet-name>bookInsert</servlet-name>
    <servlet-class>com.control.BookInsertServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>bookQuery</servlet-name>
    <url-pattern>/bookquery.do</url-pattern>
</servlet-mapping>

<servlet-mapping>
    <servlet-name>bookInsert</servlet-name>
    <url-pattern>/bookinsert.do</url-pattern>
</servlet-mapping>

選擇填空判斷

jsp的九大物件：

request 請求物件　型別 javax.servlet.ServletRequest 作用域 Request
response 回應物件 型別 javax.servlet.SrvletResponse 作用域 Page
pageContext 頁面背景關系物件 型別 javax.servlet.jsp.PageContext 作用域 Page
session 會話物件 型別 javax.servlet.http.HttpSession 作用域 Session
application 應用程式物件 型別 javax.servlet.ServletContext 作用域 Application
out 輸出物件 型別 javax.servlet.jsp.JspWriter 作用域 Page
config 配置物件 型別 javax.servlet.ServletConfig 作用域 Page
page 頁面物件 型別 javax.lang.Object 作用域 Page
exception 意外物件 型別 javax.lang.Throwable 作用域 page

servlet的典型方法：

public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException

 PrintWriter out = response.getWriter();
 out.println(xxx);

轉發和重定向：

request.setAttribute("test","hello");
request.getRequestDispatcher("/test.jsp").forword(request,response); 
response.sendRedirect("test.jsp");

html 標簽

<form action="demo-form.jsp" id="form1">
First name: <input type="text" name="fname"><br>
<input type="submit" value="提交">

執行緒同步

synchronized 同步鎖

JDBC常用幾個類

Connection conn = DriverManager.getConnection("jdbc:odbc:資料源名稱","user name","password");
pstmt = conn.prepareStatement("SELECT * FROM books WHERE bookid=?");
pstmt.setString(1, bookid);
rst = pstmt.executeQuery();

io位元組流和字符流

在這里插入圖片描述

列舉，Java常用類

interface IMessage {
	public String getMessage(); // 獲取資訊
}
enum Color implements IMessage { // 列舉類實作介面
	RED("紅色"), GREEN("綠色"), BLUE("藍色"); // 列舉物件要寫在首行
	private String title; // 成員屬性
	private Color(String title) { // 構造方法初始化屬性
		this.title = title;
	}
}

函式式介面

@FunctionalInterface
public interface MyFunc<T>{
    public  T  getValue(T t);
}

泛型

public class ObjectTool<T> {
    private T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

反射，class類及物件

        Class<?> cls = Class.forName("mldn.Student");
        Object obj = cls.newInstance();//實體化物件，jdk1.9后被廢除

list，set map

List<String> all = new ArrayList<String>(); // 為List父介面進行實體化
all.add("Java"); // 保存資料

Set<String> all = new TreeSet<String>(); // 為Set父介面進行實體化
all.add("java"); // 保存資料

Map<String, Integer> map = new HashMap<String, Integer>(); // 創建Map集合
map.put("one", 1); // 保存資料

List<String> all = new ArrayList<String>(); // 為List父介面進行實體化
all.add("小李老師"); // 保存資料
ListIterator<String> iter = all.listIterator() ;// 獲取ListIterator介面實體
System.out.print("由前向后輸出：");
while(iter.hasNext()) { // 由前向后迭代

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

標籤：java

上一篇：String,StringBuffer,StringBuilder之間的關系

下一篇：Spring Cloud（四）：feign+ribbon集成測驗

高級JAVA 臨考抱佛腳 自用

簡答題：

1.IOC容器：

2. 靜態代理

3. 工廠模式

4. Servlet生命周期

5. Sevlet 時序圖

6. 分層領域模型規約

7. 網路編程模型

8. MVC 框架

編程題

1. 多執行緒排序

2. 多執行緒求最大值

3. Web服務器：

4. JSP+Servlet+JDBC

選擇填空判斷

高級JAVA 臨考抱佛腳自用