高级JAVA 临考抱佛脚 自用

简答题:

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()) { // 由前向后迭代

相关推荐
©️2020 CSDN 皮肤主题: 程序猿惹谁了 设计师:白松林 返回首页
实付 99.90元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值