java学习基础-3_getbynameparamsql-CSDN博客

本文链接：https://blog.csdn.net/qq_29334605/article/details/106665235

异常

Java所有异常类都是 Throwable 接口的子类

Error类：Error及其子类用来描述Java运行系统中的内部错误以及资源耗尽的错误，是程序无法处理的错误, 这类的大多数错误与代码编写者执行的操作无关, 例如，程序运行时，JVM的error，无法处理，比较严重

Exception：可以通过捕捉处理使程序继续执行，是程序自身可以处理的异

运行时异常：RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常), Java编译器不会检查它，也就是说，当程序中出现这类异常时，也会编译通过

异常处理机制为：抛出异常，捕捉异常

抛出异常的方法：throws(通常被用在声明方法时，用来指定方法可能抛出的异常，多个异常可使用逗号分隔)和throw通常用在方法体中或者用来抛出用户自定义异常，并且抛出一个异常对象

line2

数据库

mysql

1. 强烈！！！不建议安装 mysql8 版本 ，mysql没有6和7版本，上个版本是 mysql v5.7

2. 启动mysq v8 cmd输入services.msc 找到mysql80 然后启动

3.配置 mysql v5.7

配置 mysql/bin 目录到系统变量path

把mysql增加到服务里，在mysql的bin目录，管理员运行cmd执行 mysqld --install

初始化data目录 mysqld --initialize

安装可视化工具 navicat

首次登录，会错误，因为系统会给一个默认密码，在data目录下找 .err 文件，找到临时密码

cmd输入 mysql -u root -p ，输入临时密码，然后修改密码 set password for root@localhost = password('123');

4.mysql使用

// 启动mysql
net start mysql　
// 关闭mysql
net stop mysql

line2

网络

网络编程都是由客户端和服务器端

1.TCP方式就类似于拨打电话，使用该种方式进行网络通讯时，需要建立专门的虚拟连接，然后进行可靠的数据传输，如果数据发送失败，则客户端会自动重发该数据
2.UDP方式就类似于发送短信，使用这种方式进行网络通讯时，不需要建立专门的虚拟连接，传输也不是很可靠，如果发送失败则客户端无法获得
-使用UDP时，每个数据报中都给出了完整的地址信息，因此无需要建立发送方和接收方的连接。

TCP和UDP的区别
1.对于TCP协议，由于它是一个面向连接的协议，在socket之间进行数据传输之前必然要建立连接，所以在TCP中多了一个连接建立的时间
2.使用UDP传输数据时是有大小限制的，每个被传输的数据报必须限定在64KB之内。
TCP没有这方面的限制，一旦连接建立起来，双方的socket就可以按统一的格式传输大量的数据。
3.UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方。
TCP是一个可靠的协议，它确保接收方完全正确地获取发送方所发送的全部数据
4.TCP在网络通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输。相比之下UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序

Url对象

URL url1 = new URL("http://www.electronjs.org/docs/");
URL url2 = new URL("http", "www.apple.com", 80, "Pages/demo.html");
System.out.println(url1.getHost());
System.out.println(url1.getQuery());

BufferedReader br = new BufferedReader(new InputStreamReader(url1.openStream()));
String line = null;
while (null != (line = br.readLine())) {
  System.out.println(line);
}
br.close();

客户端网络编程

客户端(Client)是指网络编程中首先发起连接的程序，客户端一般实现程序界面和基本逻辑实现，分为以下几步:
1 建立网络连接 客户端网络编程的第一步都是建立网络连接。在建立网络连接时需要指定连接到的服务器的IP地址和端口号，建立完成以后，会形成一条虚拟的连接，后续的操作就可以通过该连接实现数据交换了
2 交换数据 连接建立以后，就可以通过这个连接交换数据了。交换数据严格按照请求响应模型进行，由客户端发送一个请求数据到服务器，服务器反馈一个响应数据给客户端，如果客户端不发送请求则服务器端就不响应。根据逻辑需要，可以多次交换数据，但是还是必须遵循请求响应模型
3 关闭网络 连接在数据交换完成以后，关闭网络连接，释放程序占用的端口、内存等系统资源，结束网络编程。

服务器端网络编程
服务器端(Server)是指在网络编程中被动等待连接的程序，服务器端一般实现程序的核心逻辑以及数据存储等核心功能，分为以下几步
1 监听端口 服务器端被动等待连接，所以服务器端启动后，不需发起连接，而只需监听本地计算机的某个固定端口，这个端口是服务端开放给客户端的，服务端程序运行的本地计算机的IP地址就是服务器端程序的IP地址。
2 获得连接 当客户端连接服务端，服务器端就可以获得一个连接，这个连接包含客户端的信息，如客户端IP地址等，服务端和客户端通过该连接进行数据交换。一般在服务器编程中，当获得连接时，需要开启专门的线程处理该连接，每个连接都由独立的线程实现。
3 交换数据 服务端通过获得的连接进行数据交换。服务器端的数据交换步骤是首先接收客户端发送过来的数据，进行逻辑处理，再把处理以后的结果数据发送给客户端。简单来说，就是先接收再发送，这个和客户端的数据交换数序不同。其实，服务器端获得的连接和客户端连接是一样的，只是数据交换的步骤不同。当然，服务器端的数据交换也是可以多次进行的。
4 关闭连接 当服务器程序关闭时，需要关闭服务器端，通过关闭服务器端使得服务器监听的端口以及占用的内存可以释放出来，实现了连接的关闭

TCP编程

以java.net.Socket类代表客户端连接，以java.net.ServerSocket类代表服务器端连接

ClientDemo

//1：创建客户端的套接字
Socket s = new Socket("127.0.0.1", 10086);
OutputStream os = s.getOutputStream();
os.write(97);
os.write('u');
os.write(98);
os.write(99);
s.close();

ServerDemo

//1：创建服务器的套接字
ServerSocket ss = new ServerSocket(10086);
//2:监听客户端的套接字,并且返回客户端的套接字 //阻塞式方法
Socket s = ss.accept();
//3:获取输入流
InputStream is = s.getInputStream();
//4:读取数据
byte[] by = new byte[1024];
int num = 0;
while((num = is.read())!=-1){
  System.out.print((char)num);
}
//5:关闭套接字
s.close();

UDP编程
主要是 DatagramSocket 和 DatagramPacket 类

ClientDemo

// 如果不指定端口号 系统随机分配的一个本地计算机的未用端口号
DatagramSocket ds = new DatagramSocket();
String s = "Hello huahua";
String host = "127.0.0.1";
int port = 10001;
//将发送的内容转换为byte数组
byte[] data = s.getBytes();
//将服务器IP转换为InetAddress对象
InetAddress server = InetAddress.getByName(host);
//  创建发送的数据包对象
DatagramPacket sendDp = new DatagramPacket(data, data.length, server, port);
ds.send(sendDp);
ds.close();

ServerDemo

// 建发送端socket对象
DatagramSocket ds = new DatagramSocket(10001);

// DatagramPacket(byte[] buf, int length) 用来接收长度为length 的数据包。
byte[] bys = new byte[1024];
int len = bys.length;
DatagramPacket dp = new DatagramPacket(bys, len);
// 接受数据
ds.receive(dp);

InetAddress address = dp.getAddress();
String ip = address.getHostAddress();

byte[] bys2 = dp.getData();
int len2 = dp.getLength();
String s = new String(bys2, 0, len2);
System.out.println(ip + ":" + s);
ds.close();

line2

JSP

踩坑
1.jsp里的El不起作用，要加上 isELIgnored="false"

<%@ page isELIgnored="false" import="jspClass.User" pageEncoding= "utf-8"%>

jsp处理的过程

就像其他普通的网页一样，您的浏览器发送一个 HTTP 请求给服务器。
Web 服务器识别出这是一个对 JSP 网页的请求，并且将该请求传递给 JSP 引擎。通过使用 URL或者 .jsp 文件来完成。
JSP 引擎从磁盘中载入 JSP 文件，然后将它们转化为 Servlet。这种转化只是简单地将所有模板文本改用 println() 语句，并且将所有的 JSP 元素转化成 Java 代码。
JSP 引擎将 Servlet 编译成可执行类，并且将原始请求传递给 Servlet 引擎。
Web 服务器的某组件将会调用 Servlet 引擎，然后载入并执行 Servlet 类。在执行过程中，Servlet 产生 HTML 格式的输出并将其内嵌于 HTTP response 中上交给 Web 服务器。
Web 服务器以静态 HTML 网页的形式将 HTTP response 返回到您的浏览器中。
最终，Web 浏览器处理 HTTP response 中动态产生的HTML网页，就好像在处理静态网页一样

jsp生命周期

1. 编译阶段：servlet容器编译servlet源文件，生成servlet类

2. 初始化阶段：加载与JSP对应的servlet类，创建其实例，并调用它的初始化方法

3. 执行阶段：调用与JSP对应的servlet实例的服务方法

4. 销毁阶段：调用与JSP对应的servlet实例的销毁方法，然后销毁servlet实例

指令

1. page指令，定义与JSP页面相关的属性，并和JSP引擎进行通信， page指令可以运用于整个JSP文件

<%@ page language="java" import="java.util.*" pageEncoding= "utf-8"%>

2. include指令：用来指定JSP文件被编译时需要插入的资源，这个资源可以是文本、代码、HTML文件或JSP文件。 relativeURL表示要包含的文件路径。如果路径以“/”开头，则表示该路径是参照JSP应用的上下关系路径，如果路径直接以目录名或文件名开头，则表示该路径是正在使用的JSP文件的当前路径。一旦JSP文件完成编译，该资源内容就不可变，要改变该资源内容必须重新编译JSP文件, 可以将一个JSP页面分为3个不同的JSP页面：head.jsp、body.jsp和tail.jsp

<%@include file="relativeURL"%>

3. taglib指令：是页面使用者用来自定义标签。可以把一些需要重复显示的内容自定义成为一个标签，以增加代码的重用程度，并使页面易于维护

内置对象

1. request HttpServletRequest类的实例

2. response HttpServletResponse类的实例

3. out PrintWriter类的实例，用于把结果输出至网页上

4. session HttpSession类的实例

5. application ServletContext类的实例，与应用上下文有关

6. config ServletConfig类的实例

7. page 类似于Java类中的this关键字

8. pageContext PageContext类的实例，提供对JSP页面所有对象以及命名空间的访问

9. Exception Exception类的对象，代表发生错误的JSP页面中对应的异常对象

脚本

// 声明
<%! int a = 1; %>

// 表达式
<% String content3="销毁次数 : "+ 1;%>
<p><%=content3 %></p>

// Scriptlet
<%  %>

// 输出内容
<%
    //将count的输出后再加1
    out.println(a++);
    for(int b=0;b < 3;b ++){
      out.println("<div>" + b +  "</div>");
    }
%>

// 条件判断
<% if (day == 1 | day == 7) { %>
<p>今天是周末</p>
<% } else { %>
<p>今天不是周末</p>
<% } %>

initParam

在web.xml 里可以配置初始化数据

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <context-param>
    <param-name>name1</param-name>
    <param-value>mike</param-value>
  </context-param>
</web-app>

  // jsp页面可以直接用
  ${initParam.name1}

jsp作用域

使用EL的时候，默认会以一定顺序搜索四个作用域，将最先找到的变量值显示出来
imgs

JSTL

maven使用 JSTL 配置

// 开启jstl 
<dependency>
    <groupId>jstl</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
</dependency>
// 开启 servlet 
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>3.0.1</version>
  <scope>provided</scope>
</dependency>
<dependency>
  <groupId>javax.servlet.jsp</groupId>
  <artifactId>jsp-api</artifactId>
  <version>2.1</version>
  <scope>provided</scope>
</dependency>

核心标签

页面引入JSTL库
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

// 输出值的方式 ,建议使用 jstl的cout 
<% out.println(“字符串”)%>
<%=表达式%>
${name} 
<c:out value="${initParam.name1}" />


// 存值，把一个值放在指定（page、session等）的map中
<c:set value=”值1” var=”name1” [scope=”page|request|session|application”]>

// 设置scope是pageContext的属性key000
<c:set value="value000" var="key000" scope="page" />

// 修改user对象的name属性
<c:set value="huahua1" var="name" target="user" />

<c:out value="${pageScope.key000}" />

// 删除某个变量
<c:remove var="salary" scope="page"/>

// 异常捕获 
<c:catch var ="catchException">
    <% int x = 5/0;%>
</c:catch>

// 条件 
<c:if test = "${catchException != null}">
    <p>异常为 : ${catchException} <br />
        发生了异常: ${catchException.message}</p>
</c:if>

// switch case
<c:choose>
    <c:when test="${mark < 60}">
        <p>不及格</p>
    </c:when>
    <c:when test="${mark > 60 && mark <= 90}">
        <p>及格</p>
    </c:when>
    <c:when test="${mark > 90 && mark < 100}">
        <p>优秀</p>
    </c:when>
    <c:otherwise>
        神一样存在。
    </c:otherwise>
</c:choose>

// 把一个链接的数据保存在data中 
<c:import var="data" url="http://www.runoob.com"/>
<c:out value="${data}"/>

// 遍历
<c:forEach var="i" begin="1" end="5" step="1">
    Item <c:out value="${i}"/><p>
    <script>console.log(<c:out value="${i}"/>)</script>
</c:forEach>

// <c:param>标签用于在<c:url>标签中指定参数
<c:url var="myURL" value="http://huahua.com">
    <c:param name="name" value="Runoob"/>
    <c:param name="url" value="www.runoob.com"/>
</c:url>
<a href="/<c:out value="${myURL}"/>">使用 c:param 为指定URL发送两个参数。</a>
// 得到结果 
<a href="/http://huahua.com?name=Runoob&amp;url=www.runoob.com">使用 c:param 为指定URL发送两个参数。</a>

// 重定向
<c:redirect url="http://www.runoob.com"/>

JSTL格式化标签用来格式化并输出文本、日期、时间、数字。引用格式化标签库的语法

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<c:set var="now" value="<%=new java.util.Date()%>" />
<p>日期格式化: <fmt:formatDate type="both" value="${now}" /></p>

JSTL SQL标签库提供了与关系型数据库进行交互的标签

<%@ taglib prefix="sql"   uri="http://java.sun.com/jsp/jstl/sql" %>

JSTL XML标签库提供了创建和操作XML文档的标签

<%@ taglib prefix="x"  uri="http://java.sun.com/jsp/jstl/xml" %>

JSTL函数

<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<c:if test="${fn:contains(theString, 'runoob')}">
    <p>找到 runoob<p>
</c:if>

自定义标签

1.声明类

package jspClass;

public class HelloTag extends SimpleTagSupport {

  @Override
  public void doTag() throws JspException, IOException {
    JspWriter out = getJspContext().getOut();
    out.println("Hello Custom Tag!");
  }
}

2.新建WEB-INF/myTag.tld

<taglib>
    <tlib-version>1.0</tlib-version>
    <jsp-version>2.0</jsp-version>
    <short-name>Example TLD</short-name>
    <tag>
        <name>Hello</name>
        <tag-class>jspClass.HelloTag</tag-class>
        <body-content>empty</body-content>
    </tag>

</taglib>

3.页面引用

<%@ taglib prefix="ex" uri="/WEB-INF/myTag.tld"%>
<ex:Hello/>