欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

高级JAVA 临考抱佛脚 自用

程序员文章站 2022-06-24 15:03:01
简答题:1.IOC容器:IOC(Inversion of Control,控制反转)。这是spring的核心。IOC容器具有依赖注入功能的容器,IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。应用程序无需直接在代码中new相关的对象,应用程序由IOC容器进行组装。2. 静态代理为什么需要代理?因为我们可以在代理的时候做一些属于我们自己的操作。3. 工厂模式工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化,不必事先知道每次要实例化哪一...

简答题:

1.IOC容器:

IOC(Inversion of Control,控制反转)。这是spring的核心。
高级JAVA 临考抱佛脚 自用
IOC容器具有依赖注入功能的容器,IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。应用程序无需直接在代码中new相关的对象,应用程序由IOC容器进行组装。

2. 静态代理

为什么需要代理?

因为我们可以在代理的时候做一些属于我们自己的操作。
高级JAVA 临考抱佛脚 自用

3. 工厂模式

工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化,不必事先知道每次要实例化哪一个类。

高级JAVA 临考抱佛脚 自用

4. Servlet生命周期

Seevlet的生命周期由Servlet容器管理。(Tomcat是一种)

  • 加载和实例化Servlet
  • 初始化init()
  • 执行sevice()处理请求
  • 执行destroy()销毁

假如我们在代码里面把Service的方法改写了,那么这个时候的service就不是用来转向了,就是变成处理逻辑了。

5. Sevlet 时序图

高级JAVA 临考抱佛脚 自用

6. 分层领域模型规约

一、分层领域模型规约
高级JAVA 临考抱佛脚 自用

  • 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. 网络编程模型

高级JAVA 临考抱佛脚 自用

8. MVC 框架

高级JAVA 临考抱佛脚 自用

虚线是事件,实现是方法调用
高级JAVA 临考抱佛脚 自用

  • 视图: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 临考抱佛脚 自用

枚举,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://blog.csdn.net/rizero/article/details/112741737

相关标签: 个人杂记