# 技术

---

### 一、JavaWeb概述

#### 1. 什么是JavaWeb？

JavaWeb是用Java技术开发**Web应用程序**的技术栈，通过浏览器访问（如淘宝、京东）。

| 术语    | 说明                                |
| ------- | ----------------------------------- |
| B/S架构 | 浏览器/服务器，无需安装客户端       |
| C/S架构 | 客户端/服务器，需要安装软件（如QQ） |

#### 2. Web应用发展历程

| 阶段       | 技术           | 特点                         |
| ---------- | -------------- | ---------------------------- |
| 静态页面   | HTML           | 内容固定，无法交互           |
| CGI        | Perl/C         | 性能差                       |
| Servlet    | Java           | 动态生成页面，但输出HTML麻烦 |
| JSP        | Java + HTML    | 在HTML中写Java代码           |
| 前后端分离 | JSP/Vue + Ajax | 前端负责展示，后端提供接口   |

#### 3. Web服务器

| 服务器   | 说明                          |
| -------- | ----------------------------- |
| Tomcat   | 最常用，开源免费，Servlet容器 |
| Jetty    | 轻量级                        |
| JBoss    | 支持完整JavaEE                |
| WebLogic | 商业，大型项目                |

---

### 二、Tomcat服务器

#### 1. 下载安装

```cmd
# 下载地址
https://tomcat.apache.org/

# 启动
cd bin
startup.bat      # Windows
./startup.sh     # Linux

# 关闭
shutdown.bat

# 访问
http://localhost:8080
```

#### 2. Tomcat目录结构

| 目录    | 说明                            |
| ------- | ------------------------------- |
| bin     | 启动/关闭脚本                   |
| conf    | 配置文件（server.xml、web.xml） |
| lib     | 依赖jar包                       |
| logs    | 日志文件                        |
| webapps | 存放Web应用                     |
| work    | JSP编译后的Servlet              |

#### 3. 配置端口（conf/server.xml）

```xml
<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443"/>
```

---

### 三、Servlet

#### 1. 什么是Servlet？

Servlet是运行在**服务器端**的Java程序，用于处理客户端请求并返回响应。

**工作流程：**
```
浏览器 → 请求 → Tomcat → Servlet → 处理 → 响应 → 浏览器
```

#### 2. 创建Servlet

```java
// 方式1：实现Servlet接口（不常用）
// 方式2：继承HttpServlet（常用）
@WebServlet("/hello")  // 访问路径
public class HelloServlet extends HttpServlet {
    
    // 处理GET请求
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        // 设置响应类型
        resp.setContentType("text/html;charset=UTF-8");
        // 输出内容
        resp.getWriter().write("Hello JavaWeb！");
    }
    
    // 处理POST请求
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        doGet(req, resp);
    }
}
```

#### 3. web.xml配置方式

```xml
<!-- web.xml -->
<servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>com.demo.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>
```

#### 4. Servlet生命周期

| 阶段       | 方法                     | 时机                     |
| ---------- | ------------------------ | ------------------------ |
| 加载实例化 | 构造方法                 | 第一次访问或服务器启动时 |
| 初始化     | init()                   | 实例化后执行一次         |
| 处理请求   | service() → doGet/doPost | 每次请求                 |
| 销毁       | destroy()                | 服务器关闭或应用卸载     |

```java
@WebServlet("/life")
public class LifeServlet extends HttpServlet {
    
    public LifeServlet() {
        System.out.println("1. 构造方法");
    }
    
    @Override
    public void init() throws ServletException {
        System.out.println("2. init初始化");
    }
    
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        System.out.println("3. service处理请求");
        super.service(req, resp);
    }
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        System.out.println("4. doGet");
        resp.getWriter().write("OK");
    }
    
    @Override
    public void destroy() {
        System.out.println("5. destroy销毁");
    }
}
```

---

### 四、HttpServletRequest

#### 1. 获取请求参数

```java
@WebServlet("/request")
public class RequestServlet extends HttpServlet {
    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        
        // 获取单个参数
        String name = req.getParameter("name");
        String age = req.getParameter("age");
        
        // 获取多个参数（复选框）
        String[] hobbies = req.getParameterValues("hobby");
        
        // 获取所有参数名
        Enumeration<String> names = req.getParameterNames();
        
        // 获取请求方式
        String method = req.getMethod();  // GET/POST
        
        // 获取URL
        String url = req.getRequestURL().toString();  // http://localhost:8080/xxx
        String uri = req.getRequestURI();              // /项目名/路径
        
        // 获取客户端IP
        String ip = req.getRemoteAddr();
        
        // 获取请求头
        String userAgent = req.getHeader("User-Agent");
        
        // 设置编码（解决中文乱码）
        req.setCharacterEncoding("UTF-8");
    }
}
```

#### 2. 请求转发

```java
// 转发到另一个Servlet或JSP（浏览器地址栏不变）
@WebServlet("/forward")
public class ForwardServlet extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        
        // 设置数据
        req.setAttribute("message", "转发过来的数据");
        
        // 转发到 /target
        req.getRequestDispatcher("/target").forward(req, resp);
    }
}
```

---

### 五、HttpServletResponse

```java
@WebServlet("/response")
public class ResponseServlet extends HttpServlet {
    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        
        // 设置响应类型
        resp.setContentType("text/html;charset=UTF-8");
        
        // 设置状态码
        resp.setStatus(200);  // 成功
        // resp.sendError(404, "页面不存在");
        
        // 设置响应头
        resp.setHeader("Refresh", "3");  // 3秒后刷新
        
        // 输出内容
        resp.getWriter().write("输出内容");
    }
}
```

#### 2. 重定向

```java
// 重定向（浏览器地址栏改变，两次请求）
@WebServlet("/redirect")
public class RedirectServlet extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        
        // 重定向到百度
        resp.sendRedirect("https://www.baidu.com");
        
        // 重定向到项目内的其他路径
        resp.sendRedirect(req.getContextPath() + "/login");
    }
}
```

#### 3. 转发 vs 重定向

| 对比                | 转发（forward） | 重定向（redirect） |
| ------------------- | --------------- | ------------------ |
| 地址栏              | 不变            | 改变               |
| 请求次数            | 1次             | 2次                |
| 能否共享request数据 | 能              | 不能               |
| 路径写法            | 内部路径        | 完整路径或带项目名 |
| 效率                | 高              | 低                 |

---

### 六、JSP

#### 1. 什么是JSP？

JSP = HTML + Java代码，用于动态生成HTML页面。

```jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>第一个JSP</title>
</head>
<body>
    <h1>Hello JSP</h1>
    <%-- JSP注释 --%>
    <% 
        // Java代码
        String name = "张三";
        out.print("姓名：" + name);
    %>
    <p>当前时间：<%= new java.util.Date() %></p>
</body>
</html>
```

#### 2. JSP三种脚本元素

| 类型   | 语法            | 说明               |
| ------ | --------------- | ------------------ |
| 声明   | `<%! 代码 %>`   | 定义成员变量和方法 |
| 脚本   | `<% 代码 %>`    | 执行Java代码       |
| 表达式 | `<%= 表达式 %>` | 输出结果           |

```jsp
<%! 
    // 声明：成员变量
    private int count = 0;
    
    // 声明：方法
    public String getInfo() {
        return "Hello";
    }
%>

<%
    // 脚本：执行代码
    count++;
    String name = request.getParameter("name");
%>

<p>访问次数：<%= count %></p>
<p>姓名：<%= name %></p>
```

#### 3. JSP内置对象（9个）

| 对象        | 类型                | 说明                  |
| ----------- | ------------------- | --------------------- |
| request     | HttpServletRequest  | 请求对象              |
| response    | HttpServletResponse | 响应对象              |
| out         | JspWriter           | 输出对象              |
| session     | HttpSession         | 会话对象              |
| application | ServletContext      | 全局对象              |
| pageContext | PageContext         | 页面上下文            |
| config      | ServletConfig       | 配置对象              |
| page        | Object              | 当前页面对象          |
| exception   | Throwable           | 异常对象（errorPage） |

```jsp
<%
    // 使用内置对象
    request.getParameter("name");
    response.setContentType("text/html");
    out.print("输出");
    session.setAttribute("user", "张三");
    application.setAttribute("count", 100);
%>
```

#### 4. JSP指令

```jsp
<!-- page指令：页面设置 -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="java.util.*, java.sql.*" %>
<%@ page errorPage="error.jsp" %>
<%@ page isErrorPage="true" %>

<!-- include指令：静态包含 -->
<%@ include file="header.jsp" %>

<!-- taglib指令：引入标签库 -->
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
```

#### 5. JSP四大作用域

| 作用域      | 对象        | 说明     | 生命周期         |
| ----------- | ----------- | -------- | ---------------- |
| page        | pageContext | 当前页面 | 请求结束         |
| request     | request     | 一次请求 | 请求结束         |
| session     | session     | 一次会话 | 浏览器关闭或超时 |
| application | application | 整个应用 | 服务器关闭       |

```jsp
<%
    pageContext.setAttribute("pageData", "页面数据");
    request.setAttribute("reqData", "请求数据");
    session.setAttribute("sessionData", "会话数据");
    application.setAttribute("appData", "应用数据");
%>
```

---

### 七、Session和Cookie

#### 1. Cookie（客户端存储）

```java
@WebServlet("/cookie")
public class CookieServlet extends HttpServlet {
    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        
        // 创建Cookie
        Cookie cookie = new Cookie("username", "张三");
        cookie.setMaxAge(60 * 60);  // 有效期1小时（秒）
        cookie.setPath("/");         // 有效路径
        resp.addCookie(cookie);
        
        // 获取Cookie
        Cookie[] cookies = req.getCookies();
        if (cookies != null) {
            for (Cookie c : cookies) {
                if ("username".equals(c.getName())) {
                    String value = c.getValue();
                }
            }
        }
        
        // 删除Cookie
        cookie.setMaxAge(0);
        resp.addCookie(cookie);
    }
}
```

#### 2. Session（服务端存储）

```java
@WebServlet("/session")
public class SessionServlet extends HttpServlet {
    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        
        // 获取Session（true：不存在则创建）
        HttpSession session = req.getSession();
        
        // 设置属性
        session.setAttribute("userId", 1001);
        session.setAttribute("username", "张三");
        
        // 获取属性
        String username = (String) session.getAttribute("username");
        
        // 移除属性
        session.removeAttribute("username");
        
        // 设置超时时间（秒）
        session.setMaxInactiveInterval(1800);  // 30分钟
        
        // 手动销毁
        session.invalidate();
        
        // 获取Session ID
        String sessionId = session.getId();
    }
}
```

#### 3. Cookie vs Session

| 对比     | Cookie             | Session              |
| -------- | ------------------ | -------------------- |
| 存储位置 | 客户端（浏览器）   | 服务端               |
| 存储大小 | 4KB左右            | 无限制（受内存限制） |
| 安全性   | 低（可被篡改）     | 高                   |
| 生命周期 | 可设置             | 超时或手动销毁       |
| 适用场景 | 记住密码、自动登录 | 登录状态、验证码     |

#### 4. 登录案例

```java
@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        
        req.setCharacterEncoding("UTF-8");
        
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        
        // 模拟验证
        if ("admin".equals(username) && "123".equals(password)) {
            // 登录成功，保存Session
            HttpSession session = req.getSession();
            session.setAttribute("user", username);
            
            // 记住密码（Cookie）
            String remember = req.getParameter("remember");
            if ("on".equals(remember)) {
                Cookie cookie = new Cookie("username", username);
                cookie.setMaxAge(7 * 24 * 60 * 60);
                resp.addCookie(cookie);
            }
            
            resp.sendRedirect(req.getContextPath() + "/index.jsp");
        } else {
            req.setAttribute("error", "用户名或密码错误");
            req.getRequestDispatcher("/login.jsp").forward(req, resp);
        }
    }
}
```

---

### 八、过滤器

#### 1. 什么是Filter？

Filter用于拦截请求和响应，在Servlet执行前后进行处理。

**常见应用：**
- 编码过滤（解决乱码）
- 登录验证
- 日志记录
- 权限控制

#### 2. 创建Filter

```java
@WebFilter("/*")  // 拦截所有请求
public class EncodingFilter implements Filter {
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("过滤器初始化");
    }
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                         FilterChain chain) throws IOException, ServletException {
        
        // 前置处理
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        System.out.println("请求到达前");
        
        // 放行（继续执行下一个过滤器或Servlet）
        chain.doFilter(request, response);
        
        // 后置处理
        System.out.println("响应返回后");
    }
    
    @Override
    public void destroy() {
        System.out.println("过滤器销毁");
    }
}
```

#### 3. 登录验证Filter

```java
@WebFilter({"/user/*", "/admin/*"})  // 拦截需要登录的路径
public class LoginFilter implements Filter {
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                         FilterChain chain) throws IOException, ServletException {
        
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;
        
        HttpSession session = req.getSession();
        Object user = session.getAttribute("user");
        
        if (user == null) {
            // 未登录，跳转到登录页
            resp.sendRedirect(req.getContextPath() + "/login.jsp");
        } else {
            // 已登录，放行
            chain.doFilter(request, response);
        }
    }
}
```

---

### 九、监听器

#### 1. 什么是Listener？

Listener监听Web应用中的事件，在特定时机执行代码。

**监听器类型：**

| 类型       | 接口                   | 触发时机         |
| ---------- | ---------------------- | ---------------- |
| 上下文监听 | ServletContextListener | 服务器启动/关闭  |
| 会话监听   | HttpSessionListener    | Session创建/销毁 |
| 请求监听   | ServletRequestListener | 请求开始/结束    |
| 属性监听   | 对应AttributeListener  | 属性增删改       |



---

### 十、MVC模式

#### 1. 什么是MVC？

| 组件 | 全称       | 说明     | 技术                   |
| ---- | ---------- | -------- | ---------------------- |
| M    | Model      | 数据模型 | JavaBean、Service、DAO |
| V    | View       | 视图     | JSP、HTML              |
| C    | Controller | 控制器   | Servlet                |

**工作流程：**
```
浏览器 → 控制器(Servlet) → 调用Model(Service/DAO) → 获取数据 → 转发到View(JSP) → 响应
```

---



# 股票知识

## 超级云脑

---

### 一、投资决策的三大难题

在股票投资中，我们经常面临三个核心问题：

| 问题编号 | 核心问题       | 具体描述                               |
| -------- | -------------- | -------------------------------------- |
| 问题一   | 能持有吗？     | 股票买完后，不知道能不能继续持有       |
| 问题二   | 有风险吗？     | 股票在上涨过程中，不知道风险有多大     |
| 问题三   | 主力什么态度？ | 股票遇到压力时，不知道主力是在买还是卖 |

**解决方案：** 利用人工智能（AI）分析金融大数据，用AI解决决策难题。

---

### 二、超级云脑是什么？

**定义：** 超级云脑是将人工智能与金融股票领域融合的工具，能够快速处理大量金融数据，为投资者提供行情分析和预判。

**三大优势：**

| 优势       | 说明                                   |
| ---------- | -------------------------------------- |
| 处理速度快 | 瞬间处理大量金融数据                   |
| 能赚钱     | 通过大数据分析帮助投资者获利           |
| 天然匹配   | 金融市场本身就是大数据市场，AI正好适合 |

---

### 三、核心功能一：六色罗盘（判断安全与风险）

六色罗盘是一个从**绿色（安全）到红色（风险）** 的图示工具。

| 区域     | 含义   | 操作建议           |
| -------- | ------ | ------------------ |
| 绿色区域 | 安全区 | 相对安全，可持有   |
| 红色区域 | 风险区 | 注意风险，考虑减仓 |

**罗盘细分：**
- 强撑强压区
- 弱撑强压区
- 强撑中压区
- 弱撑中压区
- 强撑弱压区
- 弱撑弱压区

> **使用方法：** 看指针指向哪个区域，绿色安全，红色危险。

---

### 四、核心功能二：技术指标分析（判断压力与支撑）

技术指标分析告诉我们以下关键信息：

| 指标             | 含义                         | 示例数据           |
| ---------------- | ---------------------------- | ------------------ |
| 中长期筹码成本价 | 大多数持股者的平均成本       | 1.648              |
| 短期资金成本价   | 近期买入资金的平均成本       | 1.589              |
| 压力位           | 股价涨到这个位置可能遇到阻力 | 3.084              |
| 支撑位           | 股价跌到这个位置可能获得支撑 | 0.505              |
| 趋势             | 股价的长期运行方向           | 中长期处于上升趋势 |

**关键判断：**
- 压力强度大 → 需要放巨量才能突破
- 获利筹码增加 + 获利了结意愿不明显 → 筹码稳定性好

---

### 五、核心功能三：资金流向（判断主力态度）

| 观察点           | 判断依据         | 结论       |
| ---------------- | ---------------- | ---------- |
| 庄家在买还是卖？ | 当前多头资金占优 | 主力在买   |
| 资金是否持续？   | 多头资金持续流入 | 资金在流进 |

> **结论：** 当前市场多头资金占优，且持续流入，整体资金在流进。

---

### 六、超级云脑四大分析维度

| 维度     | 要回答的问题           | 对应功能     |
| -------- | ---------------------- | ------------ |
| 安全性   | 我的股票安全吗？       | 六色罗盘     |
| 压力点   | 涨到什么价位要注意？   | 技术指标分析 |
| 主力态度 | 主力在买还是卖？       | 资金流向分析 |
| 资金动向 | 市场资金流入还是流出？ | 资金流向分析 |

---

### 七、今日小结

| 知识点        | 掌握要求                                 |
| ------------- | ---------------------------------------- |
| 三大难题      | 能说出买完后能否持有、有无风险、主力态度 |
| 超级云脑      | 能说出它是AI+金融的分析工具              |
| 六色罗盘      | 绿色安全、红色风险                       |
| 压力位/支撑位 | 压力位是上涨阻力，支撑位是下跌支撑       |
| 资金流向      | 多头占优+持续流入=看好                   |

###