简答题：
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://blog.csdn.net/rizero/article/details/112741737
查看评论