李子菜Lizicai

Maven Li.074

Wed, 06 Jul 2022 17:25:57 +0800

Maven 坐标

Maven坐标主要组成
- groupld：定义当前Maven项目隶属组织名称（通常是域名反写，例如：org.mybatis)
- artifactld：定义当前Maven项目名称（通常是模块名称，例如CRM、SMS)
- version：定义当前项目版本号

Maven 指定本地仓库位置

Maven 软件和指定仓库位置的setting.xml都需要更改

<localRepository>D:\maven\repository</localRepository>

Maven 镜像

Maven 软件和指定仓库位置的setting.xml都需要更改

<mirror>
    <id></id>
    <mirrorOf>central</mirrorOf>
    <name></name>
    <url></url>
</mirror>

Maven 项目构建命令

# 编译
mvn compile

# 清理
mvn clean

# 测试
mvn test

# 打包
mvn package

# 安装到本地仓库
mvn install

Maven 插件创建工程

mvn archetype:generate
    -DgroupId={project-packaging}
    -DartifactId={project-name}
    -DarchetypeArtifactId=maven-archetype-quickstart
    -Dversion={project-version}
    -DinteractiveMode=false

mvn archetype:generate "-DgroupId=com.companyname.bank" "-DartifactId=consumerBanking"
"-DarchetypeArtifactId=maven-archetype-quickstart" "-DinteractiveMode=false"

Idea 创建空项目

再创建Modules 即可, 可创建多个maven工程

Maven中依赖传递

依赖具有传递性
- 直接依赖: 在当前项目中通过依赖配置建立的依赖关系
- 间接依赖: 被依赖的资源如果依赖其他资源, 当前项目间接依赖其他资源
依赖传递冲突问题
- 路径优先: 当依赖中出现相同的资源时, 层级越深, 优先级越低, 层级越浅, 优先级越高
- 声明优先: 当资源在相同层级被依赖时, 配置顺序先前的覆盖配置顺序我才看到的
- 特殊优先: 当同级配置了相同资源的不同版本, 后配置的覆盖先配置的.

Maven 依赖资源可见和排除

# 被依赖时, 其他人看到不到
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.1</version>
    <option>true</option>
</dependency>

# 排除依赖的某个资源
<dependency>
  <groupId>org.example</groupId>
  <artifactId>web02</artifactId>
  <version>1.0-SNAPSHOT</version>
  <exclusions>
    <exclusion>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
    </exclusion>
  </exclusions>
</dependency>

依赖范围

scope	主代码	测试代码	打包	范例
compile(默认)				log4j
test				junit
provided				servlet-api
runtime				jdbc

	compile	test	provided	runtime
complile	compile	test	provided	runtime
test
provided
runtime	runtime	test	provided	runtime

Maven 构建生命周期

default构建生命周期
validate（校验）	校验项目是否正确并且所有必要的信息可以完成项目的构建过程。
initialize（初始化）	初始化构建状态，比如设置属性值。
generate-sources（生成源代码）	生成包含在编译阶段中的任何源代码。
process-sources（处理源代码）	处理源代码，比如说，过滤任意值。
generate-resources（生成资源文件）	生成将会包含在项目包中的资源文件。
process-resources （处理资源文件）	复制和处理资源到目标目录，为打包阶段最好准备。
compile（编译）	编译项目的源代码。
process-classes（处理类文件）	处理编译生成的文件，比如说对Java class文件做字节码改善优化。
generate-test-sources（生成测试源代码）	生成包含在编译阶段中的任何测试源代码。
process-test-sources（处理测试源代码）	处理测试源代码，比如说，过滤任意值。
generate-test-resources（生成测试资源文件）	为测试创建资源文件。
process-test-resources（处理测试资源文件）	复制和处理测试资源到目标目录。
test-compile（编译测试源码）	编译测试源代码到测试目标目录.
process-test-classes（处理测试类文件）	处理测试源码编译生成的文件。
test（测试）	使用合适的单元测试框架运行测试（Juint是其中之一）。
prepare-package（准备打包）	在实际打包之前，执行任何的必要的操作为打包做准备。
package（打包）	将编译后的代码打包成可分发格式的文件，比如JAR、WAR或者EAR文件。
pre-integration-test（集成测试前）	在执行集成测试前进行必要的动作。比如说，搭建需要的环境。
integration-test（集成测试）	处理和部署项目到可以运行集成测试环境中。
post-integration-test（集成测试后）	在执行集成测试完成后进行必要的动作。比如说，清理集成测试环境。
verify （验证）	运行任意的检查来验证项目包有效且达到质量标准。
install（安装）	安装项目包到本地仓库，这样项目包可以用作其他本地项目的依赖。
deploy（部署）	将最终的项目包复制到远程仓库中与其他开发者和项目共享。

插件

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>3.2.1</version>
<executions>
  <execution>
    <goals>
      <goal>jar</goal>
      </goals>
    <phase>generate-test-resources</phase>
  </execution>
</executions>
</plugin>
</plugins>
</build>

Redis Li.073

Tue, 10 May 2022 16:26:20 +0800

Redis 简介

NoSQL

NoSQL: 即Not-Only SQL(泛指非关系型的数据库), 作为关系型数据库的补充.

作用: 应对基于海量用户和海量数据前提下的数据处理问题.

特征

可扩容, 可伸缩
大数据量下高性能
灵活的数据模型
高可用

类NoSQL数据库:

Redis
memcache
HBase
MongoDB

Redis安装与配置

wget https://github.com/redis/redis/archive/7.0.0.tar.gz
mkdir -p /opt
mv 7.0.0.tar.gz /opt/redis.tar.gz
cd /opt
tar -xzvf redis.tar.gz
cd redis
make

redis.conf

# 需要创建data
dir /opt/redis/data
#默认端口6379
port 6379
#绑定ip，如果是内网可以直接绑定 127.0.0.1, 或者忽略, 0.0.0.0是外网
bind 0.0.0.0
#守护进程启动
daemonize yes
#超时
timeout 300
loglevel notice
#分区
databases 16
save 900 1
save 300 10
save 60 10000
rdbcompression yes
#存储文件
dbfilename dump.rdb
#密码 abcd123
requirepass abcd123

/etc/systemd/system/redis.service, ExecStart与安装目录保持一致

[Unit]
Description=Redis7
After=redis7.service

[Service]
Type=forking
ExecStart=/opt/redis/src/redis-server /opt/redis/redis.conf 
ExecStop=/opt/redis/src/redis-cli shutdown
ExecReload=/bin/kill -s HUP $MAINPID
PrivateTmp=true
RestartSec=10
# The UNIX user and group to execute PostgreSQL as

[Install]
WantedBy=multi-user.target

启动

systemctl daemon-reload
systemctl start redis
systemctl stop redis

Redis的数据类型

String

存储的数据: 单个数据,最简单的数据存储类型, 也是最常用的数据存储类型
存储数据的格式: 一个存储空间保存一个数据
存储内容: 通常使用字符串, 如果字符串以整数的形式展示, 可以作为数字操作使用

基本操作

# 添加/修改数据
set key value
# 获取数据
get key
# 删除数据
del key
# 判定性添加数据
setnx key value

# 添加/修改多个数据
mset key1 value1 key2 value2 ...
# 获取多个数据
mget key1 key2 ...
获取数据字符个数
strlen key
追加信息到原始信息后部(如果原始信息存在就追加, 否则新建)
append key value

String 类型数据的扩展操作

# 设置数值数据增加指定范围的值
incr key
incrby key increment
incrbyfloat key increment

# 设置数值数据减少指定小范围的值
decr key
decrby key increment

# 设置数据具有指定的生命周期
setex key seconds value
psetex key milliseconds value

hash类型

新的存储需求: 对一系列存储的数据进行编组, 方便管理, 典型应用存储对象信息
需要的存储结构: 一个存储空间保存多个键值对数据
hash类型: 底层使用哈希表学习方式去实现数据存储

# 添加/修改数据
hset key field value

# 获取数据
hget key field
hgetall key

# 删除数据
hdel key field1 [field2]

# 设置field值, 如果该field存在则不做任何操作
hsetnx key field value

# 添加/修改多个数据
hmset key field1 value1 field2 value2 ...

# 获取多个数据
hmget key field1 field2 ...

# 获取哈希表中字段的数量
hlen key

# 获取哈希表中是否存在指定的字段
hexists key field

hash类型数据扩展操作

# 获取哈希表中所有的字段名或字段值
hkeys key
hvals key

# 设置指定字段的数值数据增加指定范围的值
hincrby key field increment
hincrbyfloat key field increment

List 双链结构

# 从左存入
lpush list1 zs ls ww zl

# 查询从start到end索引的数据
lrange list1 0 3
lrange list1 0 -1

# 从左移除一个
lpop list1

# 长度
llen list1

# 索引获取
lindex list1 1

list 扩展操作

# 先锋队指定数据
lrem key count value

# 规定时间内获取并移除数据, 过了拿不以则返回null
blpop key1 [key2] timeout
brpop key1 [key2] timeout
brpoplpush source destination timeout

set

# 添加数据
sadd key member1 [member2]

# 获取全部数据
smembers key

# 删除数据
srem key member1 [member2]

# 获取集合数据数量
scard key

# 判断集合中是否包含指定数据
sismember key member

# 随机获取集合中指定数量的数据
srandmember key [count]

# 随机获取集合中某个数据并将该数据移出集合
spop key [count]

Set类型数据的扩展操作

# 求两个集合的交, 并, 差集
sinter key1 [key2 ...]
sunion key1 [key2 ...]
sdiff key1 [key2 ...]

# 求两个集合的交,并,差集并存储到指定集合中
sinterstore destination key1 [key2 ...]
sunionstore destination key1 [key2 ...]
sdiffstore destination key1 [key2 ...]

# 将指定数据从原始集合中移动到目标集合中
smove source destination member

key 基本操作

# 删除指定key
del key

# 获取key是否存在
exists key

# 获取key的类型
type key

# 排序
sort

# 改名
rename key newkey
renamenx key newkey

# 为指定key设置有效期
expire key seconds
pexpire key milliseconds
expireat key timestamp
pexpireat key milliseconds-timestamp

# 获取key的有效时间
ttl key
pttl key

# 切换key从时效性黑的为永久性
persist key

# 查询scan, keys会阻塞不再推荐
SCAN cursor [MATCH pattern] [COUNT count]

scan 0 MATCH list* COUNT 5
keys pattern

# MATCH模式规则
# * 匹配什么问题数量的什么任意符号 ? 配合一个任意符号  []匹配一个指定符号

*         查询所有
hh*       查询所有以hh开头
*hh       查询所有以hh结尾
??hh      查询所有前面两个字符什么任意, 后面以hh结尾
user:?    查询所有以user:开头,最后一个字符任意
u[st]er:1 查询以u开头,以er:1结尾,中间饮食一个字母,s或t

db 基本操作

# 切换数据库
select index

# 其他操作, 测试连通
ping

# 清空当前库
flushdb

# 清空所有库
flushall

# 选择库
select

# 移动
move

# 查询库内存储个数
dbsize

Jedis

package util;

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.util.ResourceBundle;

public class JedisUtils {

    private static int maxTotal;
    private static int maxIdle;
    private static String HOST;
    private static int PORT;
    private static JedisPoolConfig jedisPoolConfig;
    private static  JedisPool jedisPool;
    static {
        ResourceBundle bundle = ResourceBundle.getBundle("redis");
        maxTotal = Integer.parseInt( bundle.getString("redis.maxTotal"));
        maxIdle = Integer.parseInt( bundle.getString("redis.maxIdel"));
        HOST = bundle.getString("redis.host");
        PORT = Integer.parseInt( bundle.getString("redis.port"));

        jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(maxTotal);
        jedisPoolConfig.setMaxIdle(maxIdle);

        jedisPool = new JedisPool(jedisPoolConfig,HOST,PORT);
    }
    public static Jedis getJedis(){

        return jedisPool.getResource();
    }
}

import redis.clients.jedis.Jedis;
import util.JedisUtils;

import java.util.List;

public class Test {
    public static void main(String[] args) {

        Jedis jedis = JedisUtils.getJedis();

        jedis.auth("password");

        jedis.set("str2","Mark");

        jedis.sadd("set1","a","B","CC");
        long longst1 = jedis.scard("set1");
        System.out.println(longst1);

        jedis.lpush("list1","ab","bc","cd","aa");
        List<String> list1 = jedis.lrange("list1", 0, -1);
        System.out.println(list1.toString());

        String str1 = jedis.get("str1");

        System.out.println(str1);

        jedis.close();
    }
}

redis.properties

redis.maxTotal=50
redis.maxIdel=10
redis.host=127.0.0.1
redis.port=6379 ```

RDB

bgsave 启动子进程进行保存, 优于save的阻塞保存方式

sava 2 10, 10秒内2次数据变化保存, sava配置在后台执行的bgsave操作

会对数据产生影响
真正产生了影响, delete不算
不进行数据比对, set s1 2, set s1 3算2次

AOF 记录操作内容

appendonly yes
appendfilename "appendonly.aof"
appenddirname "appendonlydir"
appendfsync everysec

Vue和Element二 Li.072

Mon, 14 Feb 2022 15:37:02 +0800

Vue的自定义组件

自宣言组件: 本质上, 组件是带有一个名称且可复用的Vue实例

Vue.component(组件名称,{
        props:组件的属性,
        data:组件的数据函数,
        template:组件解析的标签模板
    }
)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>自定义组件</title>
    <script src="../js2/vue.js"></script>
</head>
<body>

<div id="div">
    <my-button>我的按钮</my-button>
</div>

</body>
<script>
    Vue.component("my-button",{
        // 属性
        props:["style"] ,
        // 数据函数
        data: function (){
            return{
                msg:"我的按钮"
            }
        },
        // 解析标签模板
        template:"<button style='color:red'>{{msg}}</button>"
    });
    new Vue({
        el:"#div"
    })
</script>
</html>

Vue的生命周期

生命周期的八个阶段

状态          阶段周期
beforeCreate  创建前
created       创建后
beforeMount   载入前
mounted       载入后
beforeUpdate  更新前
updated       更新后
beforeDestroy 销毁前
destroyed     销毁后

Vue 异步操作

在Vue中发送异步请求, 本质上还是AJAX. 我们可以使用axios这个插件来简化操作
使用步骤
- 引入axios核心js文件
- 调用axios对象的方法来发起异步请求
- 调用axios对象的方法来处理响应的数据
axios常用方法

方法名                          作用
get(请求的资源路径与请求的参数) 发起GET方式请求
post(请求的资源路径,请求的参数) 发起POST方式请求
then(reponse)                   请求成功后的回调函数,通过resposnse获取响应的数据
catch(error)                    请求失败后的回调函数,通过error获取错误信息

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>异步操作</title>
    <script src="js/vue.js"></script>
    <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
</head>
<body>
<div id="div">
    {{name}}
    <button @click="send()">发起请求</button>
</div>

</body>
<script>
    new Vue({
        el:"#div",
        data:{
            name:"张三"
        },
        methods:{
            send(){
                // // Get方式请求
                // axios.get("testServlet?name="+this.name)
                // .then(resp => {
                //     alert(resp.data);
                // })
                // .catch(error =>{
                //     alert(error)
                // })

                axios.post("testServlet","name="+this.name)
                .then( resp =>{
                    alert(resp.data);
                })
                .catch( error =>{
                    alert(error)
                })
            }
        }
    })
</script>
</html>

Vue和Element一 Li.071

Thu, 30 Dec 2021 23:14:34 +0800

Vue 简介

Vue 是一套构建用户界面的渐进式前端框架。
只关注视图层，并且非常容易学习，还可以很方便的与其它库或已有项目整合。
通过尽可能简单的 API来实现响应数据的绑定和组合的视图组件。
特点
- 易用：在有HTML CSS JavaScript 的基础上，快速上手。
- 灵活：简单小巧的核心，渐进式技术栈，足以应付任何规模的应用。
- 性能：20kb min+gzip运行大小、超快虛拟DOM、最省心的优化。

Vue 入门

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>快速入门</title>
</head>
<body>

<div id="div">
    {{msg}}
</div>
</body>
<script src="js/vue.js"></script>
<script>
    // 脚本
    new Vue({
        el:"#div",
        data:{
            msg:"Hello Vue"
        }
    })
</script>
</html>

Vue 核心对象: 每一个Vue程序都是从一个Vue核心对象开始的

let vm = new Vue({
    选项列表;
})

Vue的程序包含视图和脚本两个核心部分
选项列表
- el选项: 用于接收获取到页面中的元素.(根据常用选择器获取)
- data选项: 用于保存当前Vue对象中的数据. 在视图中声明的变量需要在此处赋值
- methods选项: 用于定义方法. 方法可以直接通过对象名调用, this代表当前Vue对象
数据绑定
- 在视图部分获取脚本部分的数据
- {{变量名}}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>快速入门升级</title>
</head>
<body>
<!--    视图-->
<div id="div">
    <div>姓名:{{name}}</div>
    <div>班级:{{classRoom}}</div>
    <button onclick="hi()">打招呼</button>
    <button onclick="update()">修改班级</button>
</div>
</body>
<script src="js/vue.js"></script>
<script>
    // 脚本
    let vm = new Vue({
        el:"#div",
        data:{
            name:"张三",
            classRoom:"不一班"
        },
        methods:{
            study(){
                alert(this.name + "正在" + this.classRoom+"好好学习")
            }
        }
    })
    // 定义打招呼的方法
    function hi(){
        vm.study();
    }
    function update(){
        vm.classRoom = "地球人"
    }
</script>
</html>

Vue 常用指令

指令: 是带有v-前缀的我死属性, 不同指令具有不同含义. 例如v-html, v-if, v-for
使用指令时，通常编与在标签的属性上，值可以使用JS的表达式。
常用指令

指令      作用
v-html    把文本解析为HTML代码
v-bind    为HTML标签绑定属性值
v-if      条件性的渲染某元素,判定为true时渲染,否则不渲染
v-else    条件性的渲染某元素,判定为true时渲染,否则不渲染
v-else-if 条件性的渲染某元素,判定为true时渲染,否则不渲染
v-show    根据条件展示某元素, 区别在于切换的是display属性的值
y-for     列表渲染,           遍历容器的元素或者对象的厲性
v-on      为HTML标签绑定事件
v-model   在表单元素上创建双向数据绑定

文本插值
- v-html: 把文本解析为HTML代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>文本插值</title>
</head>
<body>
<div id="div">
    <div>{{msg}}</div>
    <div v-html="msg"></div>
</div>
</body>
<script src="../js/vue.js"></script>
<script>
    let vm = new Vue({
        el:"#div",
        data:{
            msg:"<b>Hello Vue</b>"
        }
    })
</script>
</html>

绑定属性
- v-bind:为HTML标签绑定属性值

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>绑定属性</title>
    <style>
        .my{
            border: 1px solid red;
        }
    </style>
</head>
<body>
<div id="div">
    <a v-bind:href="url">百度一下</a>
    <br>
    <a :href="url">百度一下</a>
    <br>
    <div :class="cls">我是div</div>
</div>
</body>
<script src="../js/vue.js"></script>
<script>
    new Vue({
        el:"#div",
        data:{
            url:"http://www.baidu.com",
            cls: "my"
        }
    })
</script>
</html>

条件渲染
- v-if: 条件性的渲染某元素, 判定为真时渲染,否则不渲染
- v-else:条件性的渲染
- v-else-if:条件性的渲染
- v-show:根据条件展示某元素,区别在于切换的是display属性的值

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>条件渲染</title>
</head>
<body>
<div id="div">
<!--    判断num的值, 对3取余, 余数为0显示div1 余数为1显示div2 余数为2显示div3-->
    <div v-if="num % 3 == 0">div1</div>
    <div v-else-if="num % 3 == 1">div2</div>
    <div v-else>div3</div>

    <div v-show="flag">div4</div>
</div>
</body>
<script src="../js/vue.js"></script>
<script>
    new Vue({
        el:"#div",
        data:{
            num:2,
            flag:false
        }
    })
</script>
</html>

列表渲染
- v-for:列表渲染,遍历窗口的元素或者对象的属性

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>列表渲染</title>
</head>
<body>
<div id="div">
    <ul>
        <li v-for="name in names">
            {{name}}
        </li>
        <li v-for="value in student">
            {{value}}
        </li>
    </ul>
</div>
</body>
<script src="../js/vue.js"></script>
<script>
    new Vue({
        el: "#div",
        data:{
            names:["张三","李四","王五"],
            student:{
                name:"张三",
                age:23
            }
        }
    })
</script>
</html>

事件绑定
- v-on: 为HTML标签绑定事件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>事件绑定</title>
</head>
<body>
<div id="div">
    <div>{{name}}</div>
    <button v-on:click="change">改变div的内容</button>
    <button v-on:dblclick="change">改变div的内容</button>
    <button @click="change">改变div的内容</button>
</div>
</body>
<script src="../js/vue.js"></script>
<script>
    new Vue({
        el:"#div",
        data:{
            name:"来了呀, 老弟!"
        },
        methods:{
            change(){
                this.name = "来了"
            }
        }
    })
</script>
</html>

表单绑定, 只能表单使用
- v-model:在表单元素上创建双向数据绑定
双向数据绑定
- 更新data数据, 页面中的数据也会更新
- 更新页面数据, data数据也会更新
MVVM模型(Model View ViewModel)：是MVC模式的改进版
- 在前端页面中，JS对象表示 Model，页面表示View，两者做到了最大限度的分离。
- 将Model和View 关联起来的就是ViewModel，它是桥梁。
- ViewModel 负责把 Model 的数据同步到 View 显示出来，还负责把 View 修改的数据同步回 Model.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>表单绑定</title>
</head>
<body>
<div id="div">
    <form  autocomplete="off">
        姓名: <input type="text" name="username" v-model="username">
        <br>
        年龄: <input type="number" name="age" v-model="age">
    </form>
</div>
</body>
<script src="../js/vue.js"></script>
<script>
    new Vue({
        el:"#div",
        data:{
            username:"张三",
            age:23
        }
    })
</script>
</html>

Element 组件库

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>快速入门</title>
    <link  rel="stylesheet" href="../element-ui/lib/theme-chalk/index.css">
    <script src="../js2/vue.js"></script>
    <script src="../element-ui/lib/index.js"></script>
</head>
<body>
<button>我是按钮</button>
<br>
<div id="div">
    <template>
        <el-row class="mb-4">
            <el-button>Default</el-button>
            <el-button type="primary">Primary</el-button>
            <el-button type="success">Success</el-button>
            <el-button type="info">Info</el-button>
            <el-button type="warning">Warning</el-button>
            <el-button type="danger">Danger</el-button>
            <el-button>中文</el-button>
        </el-row>
        <br>

    </template>
</div>
</body>
<script>
    new Vue({
        el:"#div"
    })
</script>
</html>

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>基础布局</title>
    <link  rel="stylesheet" href="../element-ui/lib/theme-chalk/index.css">
    <script src="../js2/vue.js"></script>
    <script src="../element-ui/lib/index.js"></script>
    <style>
    .bg-purple-dark {
            background: #99a9bf;
        }
        .bg-purple {
            background: #d3dce6;
        }
        .bg-purple-light {
            background: #e5e9f2;
        }
        .grid-content {
            border-radius: 4px;
            min-height: 36px;
        }
    </style>
</head>
<body>

<div id="div">
    <template>
        <el-row>
            <el-col :span="24"><div class="grid-content bg-purple-dark"></div></el-col>
        </el-row>
        <el-row>
            <el-col :span="12"><div class="grid-content bg-purple"></div></el-col>
            <el-col :span="12"><div class="grid-content bg-purple-light"></div></el-col>
        </el-row>
        <el-row>
            <el-col :span="8"><div class="grid-content bg-purple"></div></el-col>
            <el-col :span="8"><div class="grid-content bg-purple-light"></div></el-col>
            <el-col :span="8"><div class="grid-content bg-purple"></div></el-col>
        </el-row>
        </template>
</div>
</body>
<script>
    new Vue({
        el:"#div"
    })
</script>
</html>

布局方式

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>容器布局</title>
    <link  rel="stylesheet" href="../element-ui/lib/theme-chalk/index.css">
    <script src="../js2/vue.js"></script>
    <script src="../element-ui/lib/index.js"></script>
    <style>
        .el-header, .el-footer {
            background-color: #B3C0D1;
            color: #333;
            text-align: center;
            line-height: 60px;
        }

        .el-aside {
            background-color: #D3DCE6;
            color: #333;
            text-align: center;
            line-height: 300px;
        }

        .el-main {
            background-color: #E9EEF3;
            color: #333;
            text-align: center;
            line-height: 600px;
        }
    </style>
</head>
<body>
<div id="div">
    <el-container>
        <el-header>Header</el-header>
        <el-container>
            <el-aside width="300px">Aside</el-aside>
            <el-container>
                <el-main>Main</el-main>
                <el-footer>Footer</el-footer>
            </el-container>
        </el-container>
    </el-container>
</div>
</body>
<script>
    new Vue({
        el:"#div"
    })
</script>
</html>

表单组件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>容器布局</title>
    <link  rel="stylesheet" href="../element-ui/lib/theme-chalk/index.css">
    <script src="../js2/vue.js"></script>
    <script src="../element-ui/lib/index.js"></script>
    <style>

    </style>
</head>
<body>
<div id="div">
    <el-form ref="form" :model="form" label-width="80px">
        <el-form-item label="活动名称">
            <el-input v-model="form.name"></el-input>
        </el-form-item>
        <el-form-item label="活动区域">
            <el-select v-model="form.region" placeholder="请选择活动区域">
                <el-option label="区域一" value="shanghai"></el-option>
                <el-option label="区域二" value="beijing"></el-option>
            </el-select>
        </el-form-item>
        <el-form-item label="活动时间">
            <el-col :span="11">
                <el-date-picker type="date" placeholder="选择日期" v-model="form.date1" style="width: 100%;"></el-date-picker>
            </el-col>
            <el-col class="line" :span="2">-</el-col>
            <el-col :span="11">
                <el-time-picker placeholder="选择时间" v-model="form.date2" style="width: 100%;"></el-time-picker>
            </el-col>
        </el-form-item>
        <el-form-item label="即时配送">
            <el-switch v-model="form.delivery"></el-switch>
        </el-form-item>
        <el-form-item label="活动性质">
            <el-checkbox-group v-model="form.type">
                <el-checkbox label="美食/餐厅线上活动" name="type"></el-checkbox>
                <el-checkbox label="地推活动" name="type"></el-checkbox>
                <el-checkbox label="线下主题活动" name="type"></el-checkbox>
                <el-checkbox label="单纯品牌曝光" name="type"></el-checkbox>
            </el-checkbox-group>
        </el-form-item>
        <el-form-item label="特殊资源">
            <el-radio-group v-model="form.resource">
                <el-radio label="线上品牌商赞助"></el-radio>
                <el-radio label="线下场地免费"></el-radio>
            </el-radio-group>
        </el-form-item>
        <el-form-item label="活动形式">
            <el-input type="textarea" v-model="form.desc"></el-input>
        </el-form-item>
        <el-form-item>
            <el-button type="primary" @click="onSubmit">立即创建</el-button>
            <el-button>取消</el-button>
        </el-form-item>
    </el-form>
</div>
</body>
<script>
    new Vue({
        el:"#div",
        data() {
            return {
                form: {
                    name: '',
                    region: '',
                    date1: '',
                    date2: '',
                    delivery: false,
                    type: [],
                    resource: '',
                    desc: ''
                }
            }
        },
        methods: {
            onSubmit() {
                console.log('submit!');
            }
        }
    })
</script>
</html>

表格组件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>表格组件</title>
    <link  rel="stylesheet" href="../element-ui/lib/theme-chalk/index.css">
    <script src="../js2/vue.js"></script>
    <script src="../element-ui/lib/index.js"></script>
</head>
<body>
<div id="div">
    <template>
        <el-table
                :data="tableData"
                stripe
                style="width: 100%">
            <el-table-column
                    prop="date"
                    label="日期"
                    width="180">
            </el-table-column>
            <el-table-column
                    prop="name"
                    label="姓名"
                    width="180">
            </el-table-column>
            <el-table-column
                    prop="address"
                    label="地址">
            </el-table-column>

            <el-table-column
                    label="操作"
                    width="100">
                <el-button size="mini" type="warning">编辑</el-button>
                <el-button size="mini" type="danger">编辑</el-button>
            </el-table-column>
        </el-table>
    </template>
</div>

</body>
<script>
    new Vue({
        el:"#div",
        data() {
            return {
                tableData: [{
                    date: '2016-05-02',
                    name: '王小虎',
                    address: '上海市普陀区金沙江路 1518 弄'
                }, {
                    date: '2016-05-04',
                    name: '王小虎',
                    address: '上海市普陀区金沙江路 1517 弄'
                }, {
                    date: '2016-05-01',
                    name: '王小虎',
                    address: '上海市普陀区金沙江路 1519 弄'
                }, {
                    date: '2016-05-03',
                    name: '王小虎',
                    address: '上海市普陀区金沙江路 1516 弄'
                }]
            }
        }
    })
</script>
</html>

顶部导航栏组件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>顶部导航栏组件</title>
    <link  rel="stylesheet" href="../element-ui/lib/theme-chalk/index.css">
    <script src="../js2/vue.js"></script>
    <script src="../element-ui/lib/index.js"></script>
</head>
<body>
<div id="div">
    <el-menu :default-active="activeIndex" class="el-menu-demo" mode="horizontal" @select="handleSelect">
        <el-menu-item index="1">处理中心</el-menu-item>
        <el-submenu index="2">
            <template slot="title">我的工作台</template>
            <el-menu-item index="2-1">选项1</el-menu-item>
            <el-menu-item index="2-2">选项2</el-menu-item>
            <el-menu-item index="2-3">选项3</el-menu-item>
            <el-submenu index="2-4">
                <template slot="title">选项4</template>
                <el-menu-item index="2-4-1">选项1</el-menu-item>
                <el-menu-item index="2-4-2">选项2</el-menu-item>
                <el-menu-item index="2-4-3">选项3</el-menu-item>
            </el-submenu>
        </el-submenu>
        <el-menu-item index="3" disabled>消息中心</el-menu-item>
        <el-menu-item index="4"><a href="https://www.ele.me" target="_blank">订单管理</a></el-menu-item>
    </el-menu>
    <div class="line"></div>
    <el-menu
            :default-active="activeIndex2"
            class="el-menu-demo"
            mode="horizontal"
            @select="handleSelect"
            background-color="#545c64"
            text-color="#fff"
            active-text-color="#ffd04b">
        <el-menu-item index="1">处理中心</el-menu-item>
        <el-submenu index="2">
            <template slot="title">我的工作台</template>
            <el-menu-item index="2-1">选项1</el-menu-item>
            <el-menu-item index="2-2">选项2</el-menu-item>
            <el-menu-item index="2-3">选项3</el-menu-item>
            <el-submenu index="2-4">
                <template slot="title">选项4</template>
                <el-menu-item index="2-4-1">选项1</el-menu-item>
                <el-menu-item index="2-4-2">选项2</el-menu-item>
                <el-menu-item index="2-4-3">选项3</el-menu-item>
            </el-submenu>
        </el-submenu>
        <el-menu-item index="3" disabled>消息中心</el-menu-item>
        <el-menu-item index="4"><a href="https://www.ele.me" target="_blank">订单管理</a></el-menu-item>
    </el-menu>
</div>
</body>
<script>
    new Vue({
        el:"#div",
        data() {
            return {
                activeIndex: '1',
                activeIndex2: '1'
            };
        },
        methods: {
            handleSelect(key, keyPath) {
                console.log(key, keyPath);
            }
        }
    })
</script>
</html>

侧边导航栏

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>侧边导航栏</title>
    <link  rel="stylesheet" href="../element-ui/lib/theme-chalk/index.css">
    <script src="../js2/vue.js"></script>
    <script src="../element-ui/lib/index.js"></script>
</head>
<body>
<div id="div">
    <el-row class="tac">
    <el-col :span="3">
        <h5>自定义颜色</h5>
        <el-menu
                default-active="2"
                class="el-menu-vertical-demo"
                @open="handleOpen"
                @close="handleClose"
                background-color="#545c64"
                text-color="#fff"
                active-text-color="#ffd04b">
            <el-submenu index="1">
                <template slot="title">
                    <i class="el-icon-location"></i>
                    <span>导航一</span>
                </template>
                <el-menu-item-group>
                    <template slot="title">分组一</template>
                    <el-menu-item index="1-1">选项1</el-menu-item>
                    <el-menu-item index="1-2">选项2</el-menu-item>
                </el-menu-item-group>
                <el-menu-item-group title="分组2">
                    <el-menu-item index="1-3">选项3</el-menu-item>
                </el-menu-item-group>
                <el-submenu index="1-4">
                    <template slot="title">选项4</template>
                    <el-menu-item index="1-4-1">选项1</el-menu-item>
                </el-submenu>
            </el-submenu>
            <el-menu-item index="2">
                <i class="el-icon-menu"></i>
                <span slot="title">导航二</span>
            </el-menu-item>
            <el-menu-item index="3" disabled>
                <i class="el-icon-document"></i>
                <span slot="title">导航三</span>
            </el-menu-item>
            <el-menu-item index="4">
                <i class="el-icon-setting"></i>
                <span slot="title">导航四</span>
            </el-menu-item>
        </el-menu>
    </el-col>
    </el-row>
</div>
</body>
<script>
    new Vue({
        el:"#div",
        methods: {
            handleOpen(key, keyPath) {
                console.log(key, keyPath);
            },
            handleClose(key, keyPath) {
                console.log(key, keyPath);
            }
        }
    })
</script>
</html>

AJAX Li.070

Fri, 10 Dec 2021 11:14:44 +0800

AJAX 介绍

AJAX(Asynchronous JavaScript And XML): 异步的JavaScript和XML
本身不是新技术, 而是多个技术的综合. 用于快速创建动态网页的技术.
一般的负面如果需要更新内容, 必需重新加载整个页面
而AJAX通过浏览器与服务器进行少量数据交换, 不可以使网页异步更新. 不重新加载整个页面, 对网页部分内容局部更新

原生JavaScript 实现AJAX

核心对象：xMLHttpRequest
- 用于在后台与服务器交换数据。可以在不重新加载整个网页的情况下，对网页的某部分进行更新。
打开链接：open(method,url,async)
- method ：请求的类型 GET 或 POST.
- url：请求资源的路径,
- async：true(异步) 或false(同步）。
发送请求：send(String params)
- params：请求的参数(POST 专用）。
处理响应：onreadystatechange
- readyState ：0-请求末初始化，1-服务器连接已建立，2-请求已接收，3-请求处理中，4-请求已完成，且响应已就绪。
- status：200-响应已全部OK。
获得响应数据形式
- response Text ：获得字符串形式的响应数据。
- responseXML：获得XML形式的响应

jQuery的Get方式实现AJAX

核心语法：$.get(url,[data],[callback],[type]);
- url：请求的资源路径
- data：发送给服务器端的请求参数，格式可以是key=value，也可以是js对象
- callback ：当请求成功后的回调函数，可以在函数中编写我们的逻辑代码
- type : 预期的返回数据的类型, 取值可以是xml, html, js, ison, text等

@WebServlet("/userServlet")
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=UTF-8");

        // 1. 获取请求参数
        String username = req.getParameter("username");

        // 2. 判断姓名是否注册
        if("zhangsan".equals(username)){
            resp.getWriter().write(("<font color='red'>用户名已注册</font>"));
        }else{
            resp.getWriter().write(("<font color='green'>用户名可用</font>"));
        }
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>用户注册</title>
</head>
<body>
<form autocomplete="off" >
    姓名: <input type="text" id="username">
    <span id="uSpan"></span>
    <br>
    密码: <input type="password" id="password">
    <br>
    <input type="submit" value="注册">
</form>
</body>
<script src="js/jquery-3.6.0.min.js"></script>
<script>
// 1. 为姓名绑定推动焦点事件
    $("#username").blur(function(){
        let username = $("#username").val();
        // 2. jQuery的get方式实现AJAX
        $.get(
        "userServlet",
        "username="+username,
        // 3. 回调函数
        function(data){
            // 将响应的数据显示到span标签
            $("#uSpan").html(data)
        },
        "text"
        );
    })
</script>
</html>

jQuery的POST方式实现AJAX

核心语法：$.post(url,[data],[callback],[type])
- url：请求的资源路径
- data：发送给服务器端的请求参数，格式可以是key=value，也可以是js对象
- callback ：当请求成功后的回调函数，可以在函数中编写我们的逻辑代码
- type : 预期的返回数据的类型, 取值可以是xml, html, js, ison, text等

<script src="js/jquery-3.6.0.min.js"></script>
<script>
// 1. 为姓名绑定推动焦点事件
    $("#username").blur(function(){
        let username = $("#username").val();
        // 2. jQuery的POST方式实现AJAX
        $.post(
        "userServlet",
        "username="+username,
        // 3. 回调函数
        function(data){
            // 将响应的数据显示到span标签
            $("#uSpan").html(data)
        },
        "text"
        );
    })
</script>

jQuery的通用方式实现AJAX

核心语法: $.ajax({name:value,name:value,…});
- url ：请求的资源路径.
- async ：是否异步请求，true-是，false-否（默认是true)。
- data：发送到服务器的数据，可以是键值对形式，也可以是js对象形式。
- type：请求方式，POST或GET （默认是GET)。
- dataType：预期的返回数据的券型，取值可以是xml,html,js, json, text等。
- success ：请求成功时调用的回调函数。
- error ：请求失败时调用的回调函数。

<script src="js/jquery-3.6.0.min.js"></script>
<script>
// 1. 为姓名绑定推动焦点事件
    $("#username").blur(function(){
        let username = $("#username").val();

        $.ajax({
            url: "userServlet",
            async: true,
            data: "username=" + username,
            type: "GET",
            success: function (data) {
                $("#uSpan").html(data)
            },
            dataType: "text",
            error: function () {
                $("#uSpan").html("<font color='red'>出错了, 请稍后重试</font>")
            }
        });
    })
</script>

JSON 格式

类型	语法	说明
对象类型	{name:value,name:value,…}	name是字符串类型, value可以是任意类型
数组/集合类型	[{name:value,…},{name:value,…}]	name是字符串类型, value可以是任意类型
混合类型	{name: [{name:value,…},{name:value,…}] }	name是字符串类型, value可以是任意类型

常用方法

成员方法        说明
stringify(对象) 将指定对象转换为json格式字符串
parse(字符串)   将指定json格式字符串解析成对象

JSON Java 转换工具 jackson

类名          说明
ObjectMapper  Jackson工具包的核心类,它提供一些方法来实现JSON字符串和对象之间的转换
TypeReference 对集合泛型的反序列化,使用TypeReference可以明确的指定反序列化的对象类型

ObjectMappper 常用方法

方法名                                                 说明
String.writeValueAsString(Object.obj)                  将Java对象转换成JSON字符串
<T>T.readValue(String.json,Class<T>.valueType)         将JSON字符串转换成Java对象
<T>T.readValue(String.json,TypeReference.valueTypeRef) 将JSON字符串转换成Java对象

public class User {
    private String name;
    private Integer age;

    public User(){}
    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}

package com.example.ajax2;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;
import com.example.ajax2.User;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ObjectMapperTest {

    private ObjectMapper mapper = new ObjectMapper();
    // 1. User对象转换json, json转User对象
    @Test
    public void test01() throws JsonProcessingException {
        User user1 = new User("张三", 23);
        String json = mapper.writeValueAsString(user1);
        System.out.println("json字符串"+json);

        User user2 = mapper.readValue(json, User.class);
        System.out.println("Java对象"+user2);
    }

    // 2.map<String,String>转json json转map<String,String>

    @Test
    public void test02() throws IOException {
        Map<String,String> map = new HashMap<>();
        map.put("姓名","张三");
        map.put("性别","男");
        String json = mapper.writeValueAsString(map);
        System.out.println("json字符串"+json);

        HashMap map2 = mapper.readValue(json, HashMap.class);
        System.out.println("Map对象"+map2);

    }

    // 3. map<String,User>转json json转map<String,User>
    @Test
    public void test03() throws Exception{
        Map<String, User> map1 = new HashMap<>();
        map1.put("1", new User("张三",23));
        map1.put("2", new User("李四",24));

        String json = mapper.writeValueAsString(map1);
        System.out.println("json字符串"+json);

        HashMap map2 = mapper.readValue(json, new TypeReference<HashMap<String, User>>() {} );
        System.out.println("Map对象"+map2);
    }

    // 4.List<String>转json, json转List<String>
    @Test
    public void test04() throws Exception{
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        String json = mapper.writeValueAsString(list);
        System.out.println("json字符串"+json);

//        ArrayList<String> list2 = mapper.readVal ue(json, new TypeReference<ArrayList<String>>() { });
        ArrayList<String> list2 = mapper.readValue(json, ArrayList.class);
        System.out.println("List<string>集合"+list2);
     }

    // 5. List<User>转json, json转List<User>
    @Test
    public void test05() throws Exception {
        ArrayList<User> list1 = new ArrayList<>();
        list1.add(new User("张三",23));
        list1.add(new User("李四",24));
        String json = mapper.writeValueAsString(list1);
        System.out.println("json字符串"+json);

        ArrayList<User> list2 = mapper.readValue(json, new TypeReference<ArrayList<User>>() {
        });
        System.out.println("List对象"+list2);
    }
}

搜索联想

package com.lizicai.bean;

public class Student {
    private Integer id;
    private String name;
    private Integer age;

    private Integer score;

    public Student(){}

    public Student(Integer id, String name, Integer age, Integer score) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.score = score;
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>搜索</title>
</head>
<body>
<form autocomplete="off" >
    姓名: <input type="text" id="username" list="userlist" placeholder="输入名称搜索">
    <datalist id="userlist">
    </datalist>
</form>

</body>
<script src="js/jquery-3.6.0.min.js"></script>
<script>
    // 1. 为用户名输入框绑定鼠标点击事件
    $("#username").mousedown(function(){
        // 2. 获取用户名是否为空
        let username = $("#username").val();

        if( username == null || username == ""){
            return;
        }else{
            $.ajax({
                url: "userServlet",
                async: true,
                data: {"username":username},
                type: "POST",
                success: function (data) {
                    let names = "";
                    console.log(data)
                    for(let i=0;i<data.length;i++){
                        names +="<option>"+data[i].name+"</option>";
                        console.log(data[i])
                    }
                    $("#userlist").html(names)
                },
                dataType: "json"
            });
        }

    })
</script>
</html>

package com.lizicai.sql;

import org.apache.ibatis.jdbc.SQL;

public class ReturnSql {
    public String getSelectLikeName(){
        return new SQL(){
            {
                SELECT("*");
                FROM("student");
                WHERE("name like CONCAT('%',#{name},'%')");
                ORDER_BY("score DESC");
                LIMIT("0,4");
            }
        }.toString();
    }
}

package com.lizicai.mapper;

import com.lizicai.bean.Student;
import com.lizicai.sql.ReturnSql;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface StudentMapper {
    @SelectProvider(type = ReturnSql.class, method = "getSelectAll")
    public abstract List<Student> selectAll();

    @SelectProvider(type = ReturnSql.class, method = "getSelectLikeName")
    public abstract List<Student> selectLikeName(String name);
}

package com.lizicai.service;

import com.lizicai.bean.Student;
import com.lizicai.mapper.StudentMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class Test001 {
    @Test
    public  List<Student> selectLikeName(String name) throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        List<Student> students = mapper.selectLikeName(name);

        for (Student stu : students) {
            System.out.println(stu);
        }

        sqlSession.close();

        is.close();
        return students;
    }
}

package com.lizicai.controller;


import com.fasterxml.jackson.databind.ObjectMapper;
import com.lizicai.bean.Student;
import com.lizicai.service.Test001;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;

@WebServlet("/userServlet")
public class UserServlet extends HttpServlet {
    @Override
    public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    public void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {


        req.setCharacterEncoding("UTF-8");
        String username = req.getParameter("username");
        ObjectMapper mapper = new ObjectMapper();
        Test001 t = new Test001();
        List<Student> list =  t.selectLikeName(username);
        String json = mapper.writeValueAsString(list);

        resp.setContentType("application/json; charset=utf-8");
        PrintWriter pw = resp.getWriter();
        pw.write(json);
        pw.close();
    }
}

瀑布流分页

create database db11;
use db11;
CREATE TABLE news(
  id INT PRIMARY KEY AUTO_INCREMENT,
  title VARCHAR(999)
);

DELIMITER $$
CREATE PROCEDURE create_date()
BEGIN
    DECLARE i INT;
    SET i=1;
    WHILE i<=100 do
        INSERT INTO news VALUES (NULL,CONCAT('今天吃瓜啦,瓜',i));
        SET i=i+1;
        end WHILE;
end $$

CALL create_date();

如何确定当前显示的数据已经浏览完毕
- 公式: 滚动条距询问的距离+滚去条上下滚动的距离+当前窗口的高度>=100
- 当前文档高度: 存储10条数据,100px
- 滚去条距询问的距离: 1px
- 当前窗口的高度: 80px
- 滚去条上下滚去的距离: >=19px
前置知识

功能                  说明
$(function(){})       页面加载事件
$(window)             获取当前窗口对象
scroll()              鼠标滚去事件
$(window).height()    当前窗口的高度
$(window).scrollTop() 滚去条上下滚去的距离
$(document).height()  当前文档的高度

package com.lizicai.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.Page;
import com.lizicai.bean.News;
import com.lizicai.service.NewsService;
import com.lizicai.service.impl.NewsServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;

@WebServlet("/newsList")
public class NewsServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        String pageNum = req.getParameter("pageNum");
        String pageSize = req.getParameter("pageSize");

        System.out.println(pageNum+" "+pageSize+"----");

        Integer intPageNum = Integer.parseInt(pageNum) ;
        Integer intPageSize = Integer.parseInt(pageSize) ;

        ObjectMapper mapper = new ObjectMapper();
        NewsService newsService = new NewsServiceImpl();
        Page<News> page = newsService.pageQuery(intPageNum,intPageSize);

        String json = mapper.writeValueAsString(page);

        resp.setContentType("application/json; charset=utf-8");
        PrintWriter pw = resp.getWriter();
        pw.write(json);
        pw.close();
    }
}

package com.lizicai.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageInfo;
import com.lizicai.bean.News;
import com.lizicai.service.NewsService;
import com.lizicai.service.impl.NewsServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;

@WebServlet("/newsList2")
public class NewsServlet2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        String pageNum = req.getParameter("pageNum");
        String pageSize = req.getParameter("pageSize");

        System.out.println(pageNum+" "+pageSize+"----");

        Integer intPageNum = Integer.parseInt(pageNum) ;
        Integer intPageSize = Integer.parseInt(pageSize) ;

        ObjectMapper mapper = new ObjectMapper();
        NewsService newsService = new NewsServiceImpl();
        Page page = newsService.pageQuery(intPageNum,intPageSize);

        PageInfo<List<News>> pageInfo = new PageInfo<>(page);

        String json = mapper.writeValueAsString(pageInfo);

        resp.setContentType("application/json; charset=utf-8");
        PrintWriter pw = resp.getWriter();
        pw.write(json);
        pw.close();
    }
}

<script>
    //1.定义发送请求标记
    let send = true;

    //2.定义当前页码和每页显示的条数
    let pageNum = 1;
    let pageSize = 10;

    //3.定义滚动条距底部的距离
    let bottom = 1

    //4.设置页面加载事件
    $(function (){
        //5.为当前窗口绑定滚动条滚动事件
        $(window).scroll(function (){
            //6.获取必要信息，用于计算当前展示数据是否浏览完毕

            //当前窗口的高度
            let windowHeight = $(window).height() ;
            //当前滚动条从上往下滚动的距离
            let scrollTop = $(window).scrollTop();
            //当前文档的高度
            let docHeight = $(document).height() ;

            //7.计算当前展示数据什么时候浏览完毕
            //当 滚动条距底部的距离 + 当前滚动条滚动的距离 + 当前窗口的高度 >= 当前文档的高度
            if((bottom + scrollTop + windowHeight) >= docHeight) {
                //8.判断请求标记是否为true
                if(send == true){
                    // 如果当前页大于10，则将加载动图隐藏并结束方法

                    //9.将请求标记置为false，当前异步操作完成前，不能重新发起请求
                    send = false;
                    //10.根据当前页和每页显示的条数来 请求查询分页数据
                    queryByPage(pageNum, pageSize);
                    //11.当前页码+1
                    pageNum++;
                }
            }
        });
    })

    //请求查询分页数据的函数
    function queryByPage(pageNum, pageSize){
        //将加载动图显示
        $(".loading").show();

        //发起AJAX异步请求
        $.ajax({
            url:"newsList",
            data:{"pageNum":pageNum,"pageSize":pageSize},
            type:"POST",
            dataType:"json",
            success:function (data){
                if(data.length == 0){
                    // 加载动图隐藏
                    $(".loading").hide();
                    $("#no").html("我也是有底线的")
                    return;
                }

                // 将数据进行显示
                let titles = "";
                for(let i=0;i<data.length;i++){
                     titles += "<li>\n" +
                         "                <div class=\"title-box\">\n" +
                         "                    <a href=\"#\" class=\"link\">\n" +
                                            data[i].title+
                         "                        <hr>\n" +
                         "                    </a>\n" +
                         "                </div>\n" +
                         "            </li>";
                }
                //追加到页面
                $(".news_list").append(titles);

                //将请求标记置为true
                send = true;
            }
        })
    }
</script>

<script>
    // 1. 定义当前页码和每页显示的条数
    let pageNum = 1;
    let pageSize = 10;

    // 2. 调用查询数据的方法
    queryByPage(pageNum, pageSize)

    // 3. 定义请求查询分布数据的函数, 发起AJAX异步请求, 将数据显示到页面
    function queryByPage(pageNum, pageSize){
         $.ajax({
            url:"newsList2",
            data:{"pageNum":pageNum,"pageSize":pageSize},
            type:"POST",
            dataType:"json",
            success:function (pageInfo){
                let titles = "";
                for( let i=0;i<pageInfo.list.length;i++){
                    titles +=  "<li>\n" +
                         "                <div class=\"title-box\">\n" +
                         "                    <a href=\"#\" class=\"link\">\n" +
                                            pageInfo.list[i].title+
                         "                        <hr>\n" +
                         "                    </a>\n" +
                         "                </div>\n" +
                         "            </li>";
                }
                // 将数据显示到页面上
                $(".news_list").html(titles);

                 // 4. 为分布按钮区域设置页数参数(总页数和当前页)
                 $("#light-pagination").pagination({
                     pages:pageInfo.pages,
                     currentPage: pageInfo.pageNum
                 });

                 // 5. 为分布按钮绑定单击事件, 完成上一页下一页
                $(".page-link").click(function(){
                    // 获取点击按钮的文本内容
                     let page = $(this).html()
                    console.log(page)
                    // 如果点击的是Prev, 调用查询方法, 查询当前页的上一页数据
                    if( page == "Prev"){
                        queryByPage(pageInfo.pageNum-1, pageSize)
                    } else if(page == "Next"){
                       queryByPage(pageInfo.pageNum+1, pageSize)
                    } else{
                       queryByPage(page, pageSize)
                    }
                })
            }
         })
    }
</script>

jQuery二 Li.069

Tue, 30 Nov 2021 16:54:11 +0800

jQuery DOM

常用方法

方法        作用
html()      获取标签的文本
html(value) 设置标签的文本内容,解析标签

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>操作文本</title>
</head>
<body>
    <div id="div">我是div</div>
    <input type="button" id="btn1" value="获取div的文本">
    <input type="button" id="btn2" value="获取div的文本">
</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>
    // html()      获取标签的文本
    let div = $("div");

    // html(value) 设置标签的文本内容,解析标签
    let btn1 = $("#btn1")
    btn1.click(cc1)

    function cc1() {
        alert(div.html())
    }

    let btn2 = $("#btn2")
    btn2.click(cc2)
    function cc2(){
        div.html("<b>小明</b>")
    }

</script>
</html>

jQuery 操作对象

方法               作用
$("元素")          创建指定元素
append(element)    添加成最后一个子元素,由添加者对象调用
appendTo(element)  添加成最后一个子元素,由被添加者对象调用
prepend(element)   添加成第一个子元素,由添加者对象调用
prependTo(element) 添加成第一个子元素,由被添加者对象调用
before(element)    添加到当前元素的前面,两者是兄弟关系,由添加者对象调用
after(element)     添加到当前元素的后面,两者之间是兄弟关系,由添加者对象调用
remove()           删除指定元素(自己移除自己)
empty()            清空指定元素的所有子元素

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>操作对象</title>
</head>
<body>
<div id="div"></div>
<input type="button" id="btn1" value="添加一个span到div">
<br><br><br>

<input type="button" id="btn2" value="将加油添加到城市列表最下方"><br/>
<input type="button" id="btn3" value="将加油添加到城市列表最上方"><br/>
<input type="button" id="btn4" value="将加油添加到上海下方"><br/>
<input type="button" id="btn5" value="将加油添加到上海上方"><br/>

<ul id="city">
    <li id="bj">北京</li>
    <li id="sh">上海</li>
    <li id="gz">广州</li>
    <li id="sz">深圳</li>
</ul>
<br>

<ul id="desc">
    <li id="xg">新冠</li>
    <li id="xq">雄起</li>
</ul>

<input type="button" id="btn6" value="清除新冠"><br>
<input type="button" id="btn7" value="描述列表删除"><br>
<br>
</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>

    let div = $("#div");

    // $("元素")           创建指定元素
    // append(element)    添加成最后一个子元素,由添加者对象调用
    // 添加一个span到div
    let btn1 = $("#btn1");
    btn1.click(cc1)
    function cc1(){
        let span = $("<span>span</span>")
        div.append(span)
    }

    // appendTo(element)  添加成最后一个子元素,由被添加者对象调用
    // 将加油添加到城市列表最下方
    let city = $("#city")
    let btn2 = $("#btn2")
    btn2.click(cc2)
    function cc2(){
        let jy = $("<li id=\"jy\">加油</li>")
        jy.appendTo(city)

    }

    // prepend(element)   添加成第一个子元素,由添加者对象调用
    // 加油添加到城市列表最上方
    let btn3 = $("#btn3")
    btn3.click(cc3)
    function cc3(){
        let jy = $("<li id=\"jy\">加油</li>")
        city.prepend(jy)
    }

    // prependTo(element) 添加成第一个子元素,由被添加者对象调用


    // before(element)    添加到当前元素的前面,两者是兄弟关系,由添加者对象调用
    // 将加油添加到上海下方
    let btn5 = $("#btn5")
    btn5.click(cc5)
    function cc5(){
        let jy = $("<li id=\"jy\">加油</li>")
        let sh = $("#sh")
        sh.before(jy)
    }


    // after(element)     添加到当前元素的后面,两者之间是兄弟关系,由添加者对象调用
    let btn4 = $("#btn4")
    btn4.click(cc4)
    function cc4(){
        let jy = $("<li id=\"jy\">加油</li>")
        let sh = $("#sh")
        sh.after(jy)
    }

    // remove()           删除指定元素(自己移除自己)
    let btn6 = $("#btn6")
    btn6.click(cc5)
    function cc5(){
        let xg = $("#xg")
        xg.remove()
    }

    // empty()            清空指定元素的所有子元素
    let btn7 = $("#btn7")
    btn7.click(cc6)
    function cc6(){
        let desc = $("#desc")
        desc.empty()
    }

</script>
</html>

iQuery DOM

常用方法

方法               作用
css(name)          根据样式名称获取css样式
css(name,value)    设置CSS样式
addClass(value)    给指定的对象添加样式类名
removeClass(value) 给指定的对象删除样式类名
toggleClass(value) 如果没有样式类名,则添加,如果有,则删除

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>操作样式</title>
    <style>
        .cls1{
            background: pink;
            height: 30px;
        }
    </style>
</head>
<body>

<div style="border: 1px solid red;" id="div">我是div</div>
<input type="button" id="btn1" value="获取div样式"><br/>
<input type="button" id="btn2" value="设置div的背景色为蓝色"><br/>
<input type="button" id="btn3" value="给div设置cls1样式"><br/>
<input type="button" id="btn4" value="给div删除cls1样式"><br/>
<input type="button" id="btn5" value="给div设置或删除cls1样式"><br/>

</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>

    let div = $("#div")
    // css(name)          根据样式名称获取css样式
    let btn1 = $("#btn1")
    btn1.click(get1)
    function get1(){
        alert(div.css("border"))
    }

    // css(name,value)    设置CSS样式
    // div背景色为蓝色
    let btn2 = $("#btn2")
    btn2.click(get2)
    function get2(){
        div.css("background","blue")
    }

    // addClass(value)    给指定的对象添加样式类名
    let btn3 = $("#btn3")
    btn3.click(get3)
    function get3(){
        div.addClass("cls1");
    }

    // removeClass(value) 给指定的对象删除样式类名
    let btn4 = $("#btn4")
    btn4.click(get4)
    function get4(){
        div.removeClass("cls1");
    }

    // toggleClass(value) 如果没有样式类名,则添加,如果有,则删除
    let btn5 = $("#btn5")
    btn5.click(get5)
    function get5(){
        div.toggleClass("cls1");
    }

</script>
</html>

jQuery DOM 操作属性

方法               作用
attr(name,[value]) 获得/设置属性的值
prop(name,[value]) 获得/设置属性的值(checked,selected)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>操作属性</title>
</head>
<body>
<input type="text" id="username">
<br>
<input type="button" id="btn1" value="获取输入框的id属性">
<br/>
<input type="button" id="btn2" value="给输入框设置value属性">
<br/>

<input type="radio" name="gender" id="gender1">男
<input type="radio" name="gender" id="gender2">女
<br/>

<input type="button" value="选中女" id="btn3">
<br/>


<select>
    <option>---请选择---</option>
    <option id="bk">本科</option>
    <option id="zk">专科</option>
</select>
<br/>

<input type="button" value="选中本科" id="btn4">
</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>
    // 获取输入框的id属性
    let username = $("#username")
    let btn1 = $("#btn1")
    btn1.click(test1)
    function test1(){
        alert(username.attr("id"))
    }

    // 给输入框设置value属性
    let btn2 = $("#btn2")
    btn2.click(test2)
    function test2(){
        username.attr("value","哈哈")
    }

    // 选中女
    $("#btn3").click(function (){
        $("#gender2").prop("checked",true)
    })

    // 选中本科
    let bk = $("#bk")
    let btn4 = $("#btn4")
    btn4.click(test4)
    function test4(){
        bk.prop("selected",true)
    }
</script>
</html>

操作复选框

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>复选框</title>
</head>
<body>
    <table id="tab1" border="1" width="800" align="center">
        <tr>
            <th style="text-align: left">
                <input style="background:lightgreen" id="selectAll" type="button" value="全选">
                <input style="background:lightgreen" id="selectNone" type="button" value="全不选">
                <input style="background:lightgreen" id="reverse" type="button" value="反选">
            </th>

            <th>分类ID</th>
            <th>分类名称</th>
            <th>分类描述</th>
            <th>操作</th>
        </tr>
        <tr>
            <td><input type="checkbox" class="item"></td>
            <td>1</td>
            <td>手机数码</td>
            <td>手机数码类商品</td>
            <td><a href="">修改</a>|<a href="">删除</a></td>
        </tr>
        <tr>
            <td><input type="checkbox" class="item"></td>
            <td>2</td>
            <td>电脑办公</td>
            <td>电脑办公类商品</td>
            <td><a href="">修改</a>|<a href="">删除</a></td>
        </tr>
        <tr>
            <td><input type="checkbox" class="item"></td>
            <td>3</td>
            <td>鞋靴箱包</td>
            <td>鞋靴箱包类商品</td>
            <td><a href="">修改</a>|<a href="">删除</a></td>
        </tr>
        <tr>
            <td><input type="checkbox" class="item"></td>
            <td>4</td>
            <td>家居饰品</td>
            <td>家居饰品类商品</td>
            <td><a href="">修改</a>|<a href="">删除</a></td>
        </tr>
    </table>
</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>
    //全选
    //1.为全选按钮添加单击事件
    $("#selectAll").click(function(){
        //2.获取所有的商品复选框元素，为其添加checked属性，属性值true
        $(".item").prop("checked",true);
    });


    //全不选
    //1.为全不选按钮添加单击事件
    $("#selectNone").click(function(){
        //2.获取所有的商品复选框元素，为其添加checked属性，属性值false
        $(".item").prop("checked",false);
    });


    //反选
    //1.为反选按钮添加单击事件
    $("#reverse").click(function(){
        //2.获取所有的商品复选框元素，为其添加checked属性，属性值是目前相反的状态
        let items = $(".item");
        items.each(function(){
            $(this).prop("checked",!$(this).prop("checked"));
        });
    });
</script>
</html>

随机图片

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>随机图片</title>
</head>
<body>
<!-- 小图 -->
<div style="background-color:red;border: dotted; height: 50px; width: 50px">
    <img src="img/01.jpg" id="small" style="width: 50px; height: 50px;">
</div>
<!-- 大图 -->
<div style="border: double ;width: 400px; height: 400px; position: absolute; left: 500px; top:10px">
    <img src="" id="big" style="width: 400px; height: 400px; display:none;">
</div>

<!-- 开始和结束按钮 -->
<input id="startBtn" type="button" style="width: 150px;height: 150px; font-size: 20px" value="开始">
<input id="stopBtn" type="button" style="width: 150px;height: 150px; font-size: 20px" value="停止">
</body>
<script src="js/jquery-3.3.1.min.js"></script>
<script>
    //1.准备一个数组
    let imgs = [
        "img/01.jpg",
        "img/02.jpg",
        "img/03.jpg",
        "img/04.jpg",
        "img/05.jpg",
        "img/06.jpg",
        "img/07.jpg",
        "img/08.jpg",
        "img/09.jpg",
        "img/10.jpg"];

    //2.定义计数器变量
    let count = 0;

    //3.声明定时器对象
    let time = null;

    //4.声明图片路径变量
    let imgSrc = "";

    //5.为开始按钮绑定单击事件
    $("#startBtn").click(function(){
        //6.设置按钮状态
        //禁用开始按钮
        $("#startBtn").prop("disabled",true);
        //启用停止按钮
        $("#stopBtn").prop("disabled",false);

        //7.设置定时器，循环显示图片
        time = setInterval(function(){
            //8.循环获取图片路径
            let index = count % imgs.length; // 0%10=0  1%10=1  2%10=2 .. 9%10=9  10%10=0

            //9.将当前图片显示到小图片上
            imgSrc = imgs[index];
            $("#small").prop("src",imgSrc);

            //10.计数器自增
            count++;
        },10);
    });


    //11.为停止按钮绑定单击事件
    $("#stopBtn").click(function(){
        //12.取消定时器
        clearInterval(time);

        //13.设置按钮状态
        //启用开始按钮
        $("#startBtn").prop("disabled",false);
        //禁用停止按钮
        $("#stopBtn").prop("disabled",true);

        //14.将图片显示到大图片上
        $("#big").prop("src",imgSrc);
        $("#big").prop("style","width: 400px; height: 400px;");
    });

</script>
</html>

jQuery一 Li.068

Wed, 24 Nov 2021 10:52:40 +0800

jQuery 介绍

jQuery是一个JavaScript库
封装了很多预定义的函数, 获取元素, 执行隐藏移动等
目的就是在使用时直接调用, 不需要再重复定义, 这样就可以极大地简化了JavaScript编程

jQuery 快速入门

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>快速入门jQuery</title>
</head>
<body>
    <div id="div">我是div</div>
</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>
    // let div = document.getElementById("div");
    // alert(div.innerText)


    // jQuery 方式

    let jqDiv = $("#div");
    alert(jqDiv)
    alert(jqDiv.html())
</script>
</html>

JS对象和jQuery对象黑的

jQuery本质上虽然也是JS, 但如果想使用jQuery的属性和方法那么必须保证对象是jQuery对象, 而不是JS方式获得的DOM对象
二者的API方法不能混合使用, 若想使用对方的API, 需要进行对象转换
JS的DOM对象黑的成jQuery对象
- $(JS的DOM对象);
jQuery对象转换成jQuery对象
- jQuery对象[索引];
- jQuery对象.get(索引);

<body>
<div id="div">我是div</div>

</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>
    // js 方式, 通过id获取div元素
    // JS对象  转换    jQuery对象
    let div1 = document.getElementById("div");
    jsDiv1 = $(div1)
    alert(jsDiv1.html())


    // jQuery对象  转换  DOM对象

    let jqDiv2 = $("#div");
    let div2 = jqDiv2[0]
    alert(div2.innerText)

    let div3 = jqDiv2.get(0)
    alert(div3.innerText)

</script>

jQuery事件的使用

常用事件
jQuery中将事件封装成了对应的方法. 去年了JS中的.on语法.

事件名 说明
onload 某个页面或图像被完成加载
onsubmit 当表单提交时触发该事件
onclick 鼠标单击事件
ondblclick 鼠标双击事件
onblur 元素失去焦点
onfocus 元素获得焦点
onchange 用户改变真苦域的内容

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>事件的使用</title>
</head>
<body>
    <input type="button" id="btn" value="点我">
    <br>
    <input type="text" id="input">
</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>
    let btn = $("#btn")
    btn.click(check)
    function check(){
        alert("点我干嘛")
    }

    $("#btn").click(function () {
        alert("匿名函数")
    })


    // 获取焦点事件
    let input = $("#input")
    input.focus(getFocus)
    function getFocus(){
        // alert("你要输入数据了")
    }

    input.blur(loseFocus)
    function loseFocus(){
        alert("你输入完成了")
    }

</script>
</html>

事件的绑定和解绑

绑定事件
- jQuery对象.on(事件名称,执行的功能);
解绑事件
- jQuery对象.off(事件名称) 如果不指定事件名称,则会把该对象绑定的所有事件都解绑

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>事件的绑定和解绑</title>
</head>
<body>
    <input type="button" id="btn1" value="点我">
    <input type="button" id="btn2" value="解绑">
</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>
    // 1. 给btn1 绑定一个单击的事件
    let btn1 = $("#btn1");
    btn1.on("click", cc)
    function cc(){
        alert("点我干嘛")
    }

    let btn2 = $("#btn2")
    btn2.on("click", jiebang)
    function jiebang(){
        btn1.off("click")
    }
</script>
</html>

事件的切换

事件的切换: 需要给同一个对象绑定多个事件, 而且多个事件还有先后顺序关系
方式一: 单独定义
- $(元素).事件方法名(要执行的功能);
- $(元素).事件方法名(要执行的功能);
方式二: 链式定义
- $(元素).事件方法名1(要执行的功能).事件方法名2(要执行的功能) …

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>事件的切换</title>
    <style>
        #div{
            border: 1px solid black;
        }
    </style>
</head>
<body>
    <div id="div">dvi</div>
</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>
    // 方式一, this的使用

    // $("#div").mouseover(function () {
    //     $(this).css("background","red");
    // })

    // 方式一, 单独定义
    let div = $("#div");
    // div.on("mouseover", changeRed)
    // div.on("mouseout",changeBlue)
    function changeRed(){
        div.css("background-color","red")
    }
    function changeBlue(){
        div.css("background-color","blue")
    }

    // 方式二, 链式定义
    div.on("mouseover", changeRed).on("mouseout",changeBlue)

</script>
</html>

遍历

方式一: 传统方式

for (let i=0;i<窗口对象长度;i++){
    执行功能;
}

方式二:对象.each()方法

容器对象.each(function(index,ele){
    执行功能;
})

方式三:$.each()方法

$.each(容器对象,function(index.ele){
    执行功能;
});

方式四: for of 语句

for(ele of 容器对象){
    执行功能;
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>遍历</title>
</head>
<body>
    <input type="button" id="btn" value="遍历列表项">
    <ul>
        <li>前端</li>
        <li>后端</li>
        <li>全占工程师</li>
    </ul>
</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>

    $("#btn").on("click", showCicle4);

    // 方式一: 传统方式
    let lis = document.getElementsByTagName("li");

    function showCicle1(){
        for(let i=0; i< lis.length; i++){
            console.log(lis[i].innerHTML+" ")
        }
        document.write("<br/>")
    }


    // 方式二: 对象.each()方法
    let lis2 = $("li")
    function showCicle2(){
        lis2.each(function(index,ele){
            console.log(ele.innerHTML+" ")
        });
        document.write("<br/>")
    }


    // 方式三: $.each()方法
    let lis3 = $("li")
    function showCicle3(){
        $.each(lis3,function(index,ele){
            console.log(ele.innerHTML+" ")
        });
        document.write("<br/>")
    }

    // 方式四: ele of 容器
    let lis4 = $("li")
    function showCicle4(){
        for(ele of lis4){
            console.log(ele.innerHTML+" ")
        }
        document.write("<br/>")
    }
</script>
</html>

jQuery 基本选择器

id选择器, 类选择器, 元素选择器, 属性选择器等等
jQuery中选择器的语法:$()
基本选择器

选择器     语法              作用
元素选择器 $("元素名称");    根据元素名称获取元素对象们
id选择器   $("#id属性值")    根据id属性值获取元素对象
类选择器   $(".class属性值") 根据class属性值获取元素对象位

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>基本选择器</title>
</head>
<body>
  <div id="#div1">div1</div>
  <div class="div2">div2</div>
  <div class="div2">div3</div>
</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>
    let divs = $("div")
    alert(divs.length)

    let div1 = $("#div1");
    alert(div1)

    let div2 = $(".div2")
    alert(div2.length)
</script>
</html>

jQuery 层级选择器

选择器     语法       作用
后代选择器 $("A B")   A下的所有B(包括B的子级)
子选择器   $("A > B") A下的所有B(不包括B的子级)
兄弟选择器 $("A + B") A相邻的下一个B
兄弟选择器 $("A ~ B") A相邻的所有B

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>层级选择器</title>
</head>
<body>

    <div>
        <span>s1
            <span>s1-1</span>
            <span>s1-2</span>
        </span>
        <span>s2</span>
    </div>
    <div></div>
    <p>p1</p>
    <p>p2</p>

</body>
<script src="../jQuery/jquery-3.6.0.js "></script>
<script>
    // 1. 后代选择器 $("A B") A下的所有B(包括B的子级)
    let spans = $("div span");
    // alert(spans.length)

    // 子选择器   $("A > B") A下的所有B(不包括B的子级)
    let spans2 = $("div > span")
    // alert(spans2.length)

    // 兄弟选择器 $("A + B") A相邻的下一个B
    let p1 = $("div+p")
    alert(p1.html())

    // 兄弟选择器 $("A ~ B") A相邻的所有B
    let p2 = $("div ~ p")
    alert(p2.length+" "+p2[0].innerHTML)

</script>
</html>

jQuery 属性选择器

选择器       语法                   作用
属性名选择器 $("A[属性名]");        根据指定属性名获取元素对象们
属性值选择器 $("A[属性名=属性值]"); 根据指定属性名和属性值获取元素对象们

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>属性选择器</title>
</head>
<body>

<input type="text">
<input type="password">
<input type="password">

</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>
    // 属性名选择器 $("A[属性名]");        根据指定属性名获取元素对象们
    let inputs = $("input[type]");
    // alert(inputs.length)

    // 属性值选择器 $("A[属性名=属性值]"); 根据指定属性名和属性值获取元素对象们
    let inputs2 = $("input[type='password']")
    alert(inputs2.length)

</script>
</html>

jQuery 过滤器选择器

选择器         语法             作用
首元素选择器   $("A:first");    获得选择的元素中的第一个元素
尾元素选择器   $("A:last");     获得选择的元素中的最后一个元素
非元素选择器   $("A:not(B)");   不包括指定内容的元素
偶数选择器     $("A:even");     偶数,从0开始计数
奇数选择器     $("A:odd");      奇数,从0开始计数
等于索引选择器 $("A:eq(index)") 指定索引元素,和数组索引一致
大于索引选择器 $("A:gt(index)") 大于指定索引元素
小于索引选择器 $("A:lt(index)") 小玩指定索引元素

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>过滤器选择器</title>
</head>
<body>
<div>div1</div>
<div id="div2">div2</div>
<div>div3</div>
<div>div4</div>
</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>
    // 首元素选择器   $("A:first");    获得选择的元素中的第一个元素
    let divFirst = $("div:first");
    // alert(divFirst.html())

    // 尾元素选择器   $("A:last");     获得选择的元素中的最后一个元素
    let divLast = $("div:last");
    // alert(divLast.html())

    // 非元素选择器   $("A:not(B)");   不包括指定内容的元素
    let divs3 = $("div:not(#div2)")
    // alert(divs3.length)

    // 偶数选择器     $("A:even");     偶数,从0开始计数
    let divs4 = $("div:even")
    // alert(divs4.length)
    // alert(divs4[0].innerHTML)
    // alert(divs4[1].innerHTML)

    // 奇数选择器     $("A:odd");      奇数,从0开始计数
    let divs5 = $("div:odd")
    // alert(divs5.length)
    alert(divs5[0].innerHTML)
    alert(divs5[1].innerHTML)

    // 等于索引选择器 $("A:eq(index)") 指定索引元素,和数组索引一致
    let divs6 = $("div:eq(2)")
    // alert(divs6.html())

    // 大于索引选择器 $("A:gt(index)") 大于指定索引元素
    let divs7 = $("div:gt(0)")
    // alert(divs7.length)

    // 小于索引选择器 $("A:lt(index)") 小玩指定索引元素
    let divs8 = $("div:lt(4)")
    // alert(divs8.length)

</script>
</html>

jQuery 表单属性选择器

选择器                  语法             作用
可用元素选择器          $("A:enabled");  获得可用元素
不可用元素选择器        $("A:disabled"); 获得不可用元素
单选/复选框被选中的元素 $("A:checked");  获得单选/复选框被选中的元素
下拉框被选中的元素      $("A:selected"); 获得下拉框选中的元素

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>表单选择器</title>
</head>
<body>
<input type="text" disabled>
<input type="text">
<input type="radio" name="gender" value="men" checked>男
<input type="radio" name="gender" value="women">女
<input type="checkbox" name="hobby" value="study" checked>
<input type="checkbox" name="hobby" value="sleep" checked>

<select>
    <option>---请选择---</option>
    <option selected>本科</option>
    <option>专科</option>
</select>
</body>
<script src="../jQuery/jquery-3.6.0.js"></script>
<script>
    // 可用元素选择器          $("A:enabled");  获得可用元素
    let inputs1 = $("input:enabled");
    // alert(inputs1.length)

    // 不可用元素选择器        $("A:disabled"); 获得不可用元素
    let inputs2 = $("input:disabled");
    // alert(inputs2.length)

    // 单选/复选框被选中的元素 $("A:checked");  获得单选/复选框被选中的元素
    let inputs3 = $("input:checked");
    // alert(inputs3.length)

    // 下拉框被选中的元素      $("A:selected"); 获得下拉框选中的元素
    let selects1 = $("option:selected")
    alert(selects1.get(0).innerHTML)

</script>
</html>

JavaScript二 Li.067

Fri, 19 Nov 2021 23:12:49 +0800

JavaScript 面向对象, 类的定义和使用

定义格式

class 类名{
    constructor(变量列表){
        变量赋值;
    }
    方法名(参数列表){
        方法体;
        return 返回值;
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>类的定义和使用</title>
</head>
<body>

</body>

<script>
    class Person{
        constructor(name,age) {
            this.name = name
            this.age = age
        }

        // show method
        show(){
            document.write(this.name+" "+this.age+"<br/>");
        }

        eat(){
            document.write("吃饭<br>");
        }
    }

    let p = new Person("张三",23)
    p.show()
    p.eat()
</script>
</html>

字面量定义类和使用

let 对象名 = {
    变量名 : 变量值,
    变量名 : 变量值,
    ...

    方法名 : function(参数列表){
        方法体;
        return 返回值;
    }
    ...
};

使用格式
- 对象名.变量名
- 对象名.方法名();

<script>
    let person = {
        name : "张三",
        age : 23,
        hobby : ["听课","学习"],
        show : function (){
            document.write(this.name+" "+this.age+"<br>")
        },

        eat : function (){
            document.write("吃饭")
        }
    }
    document.write(person.name+person.age+person.hobby[0]+","+person.hobby[1]+"<br/>")
    person.eat()
</script>

继承

继承: 让类与类产生子父类的关系,子类可以使用父类有权限的成员
继承关键字: extends
顶级父类: Object

<script>
    class Person{
        constructor(name,age) {
            this.name = name
            this.age = age
        }

        // show method
        show(){
            document.write(this.name+" "+this.age+"<br/>");
        }
    }

    class Worker extends Person{
        constructor(name,age,salary) {
            super(name, age);
            this.salary = salary
        }
        show(){
            document.write(this.name+this.age+this.salary)
        }
    }

    var w = new Worker("张三",23,10000)
    w.show()
</script

JavaScript 内置对象

Number

方法名       说明
parseFloat() 将传入的字符串浮点数转为浮点数
parseInt()   将传入的字符串整数转为整数

<script>
    // 1. parseFloat() 将传入的字符串浮点数转为浮点数
    document.write(Number.parseFloat("2.333"))
    document.write("<br>")
    document.write(Number.parseFloat("2.333")+2)
    document.write("<br>")

    // 2. parseInt() 将传入的字符串整数转为整数
    document.write(Number.parseInt("100"))
    document.write("<br>")
    document.write(Number.parseInt("100")+20)
    document.write("<br>")
    document.write(Number.parseInt("1100ab"))
    document.write("<br>")

</script>

Math

方法名 说明
ceil(x) 向上取整
floor(x) 向下取整
round(x) 把数四舍五入为最接近的整数
random() 随机数,返回的是0.0-1.0之间范围(含头不含尾)
pow(x,y) 幂运算的x的y次方

<script>
    // ceil(x) 向上取整
    document.write(Math.ceil(4.4))
    document.write("<br>")

    // floor(x) 向下取整
    document.write(Math.floor(4.4))
    document.write("<br>")

    // round(x) 把数四舍五入为最接近的整数
    document.write(Math.round(4.1))
    document.write("<br>")
    document.write(Math.round(4.6))
    document.write("<br>")

    // random() 随机数,返回的是0.0-1.0之间范围(含头不含尾)
    document.write(Math.random())
    document.write("<br>")

    // pow(x,y) 幂运算的x的y次方
    document.write(Math.pow(2,3))
</script>

Date

构造方法                                                  说明
Date()                                                    根据当前时间创建对象
Date(value)                                               根据指定毫秒值创建对象
Date(year,month,[day,hours,minutes,seconds,milliseconds]) 根据指定字段你出去对象(月份是0-11)

成员方法         说明
getFullYear()    获取年份
getMonth()       获取月份
getDate()        获取天数
getHours()       获取小时
getMinutes()     获取分钟
getSeconds()     获取秒数
getTime()        返回距1970年1月1日至今的毫秒数
toLocaleString() 返回本地日期格式的字符串

<script>
    // Date()                                                    根据当前时间创建对象
    let d1 = new Date()
    document.write(d1)
    document.write("<br>")

    // Date(value)                                               根据指定毫秒值创建对象
    let d2 = new Date(20000)
    document.write(d2)
    document.write("<br>")

    // Date(year,month,[day,hours,minutes,seconds,milliseconds]) 根据指定字段你出去对象(月份是0-11)
    let d3 = new Date(2022,9,3,4,5,6)
    document.write(d3)
    document.write("<br>")


    // getFullYear()    获取年份
    document.write(d3.getFullYear())
    document.write("<br>")

    // getMonth()       获取月份
    document.write(d3.getMonth())
    document.write("<br>")

    // getDate()        获取天数
    document.write(d3.getDate())
    document.write("<br>")

    // getHours()       获取小时
    document.write(d3.getHours())
    document.write("<br>")

    // getMinutes()     获取分钟
    document.write(d3.getMinutes())
    document.write("<br>")

    // getSeconds()     获取秒数
    document.write(d3.getSeconds())
    document.write("<br>")

    // getTime()        返回距1970年1月1日至今的毫秒数
    document.write(d3.getTime())
    document.write("<br>")

    // toLocaleString() 返回本地日期格式的字符串
    document.write(d3.toLocaleString())
    document.write("<br>")

</script

String 内置对象

构造方法 说明
String(value) 根据指定字符串创建对象
let s="字符串" 直接赋值

成员方法 说明
length属性           获取字符串长度
charAt(index)        获取指定索引处的字符
indexOf(value)       获取指定字符串出现的索引位置,换不到为-1
substring(start,end) 根据指定索引范围截取字符串(含头不含尾)
split(value)         根据指定规则切割字符串,返回数组
replace(old,new)     使用新字符串替换老字符串

<script>
    //     String(value) 根据指定字符串创建对象
    let s1 = new String("Hello")
    document.write(s1)
    document.write("<br>")

    //     let s="字符串" 直接赋值
    let s2 = "World"
    document.write(s2)
    document.write("<br>")

    //     成员方法 说明
    //     length属性           获取字符串长度
    let s3 = "What is you name!"
    document.write(s3.length)
    document.write("<br>")

    //     charAt(index)        获取指定索引处的字符
    document.write(s3.charAt(10))
    document.write("<br>")

    //     indexOf(value)       获取指定字符串出现的索引位置,换不到为-1
    document.write(s3.indexOf("a"))
    document.write("<br>")

    //     substring(start,end) 根据指定索引范围截取字符串(含头不含尾)
    document.write(s3.substring(0,4))
    document.write("<br>")

    //     split(value)         根据指定规则切割字符串,返回数组
    let s5arr = s3.split("\\s")
    for(ss of s5arr){
        document.write(ss)
    }
    document.write("<br>")

    //     replace(old,new)     使用新字符串替换老字符串
    let s6 = "What is youuuu name!"
    document.write(s6.replace("uu","s"))
    document.write("<br>")

</script>

RegExp
正则表达: 是一种对字符串进行匹配的规则

构造方法         说明
RegExp(规则)     根据指定规则创建对象
let reg=/^规则$/ 直接赋值

成员方法           说明
test(匹配的字符串) 根据指定规则验证字符串是否符合

规则

表达式 说明
[a]    只能是a
[abc]  只能是abc中的某一个
[1]    只能是1
[123]  只能是123中的某一个
[a-z]  只能a到z中某一个
[A-Z]  只能A到Z中某一个
[0-9]  只能0到9中某一个
{5}    只能出现5次
{4,6}  只能出现4到6次

<script>
    // RegExp(规则)     根据指定规则创建对象
    let regx1 = new RegExp("[1][358][0-9]{9}")
    document.write(regx1.test(13510002000))
    document.write("<br>")
    document.write(regx1.test(12510002000))
    document.write("<br>")

    // let reg=/^规则$/ 直接赋值
    let regx2 =/^[\\_0-9a-zA-Z]{4,16}$/
    document.write(regx2.test("_sdkfj."))
    document.write("<br>")
    document.write(regx2.test("_dkjf23"))
    document.write("<br>")

</script>

Array

成员方法       说明
push(元素)     添加元素到数组的末尾
pop()          删除数组末尾的元素
shift()        删除数组最前面的元素
includes(元素) 判断数组是否包含给定的值
reverse()      反转数组中的元素
sort()         对数组元素进行排序

<script>
    // push(元素)     添加元素到数组的末尾
    let arr = [4,2,3,5,1]
    arr.push(8)
    for(let a of arr){
        document.write(a+" ")
    }
    document.write("<br>")

    // pop()          删除数组末尾的元素
    arr.pop()
    for(let a of arr){
        document.write(a+" ")
    }
    document.write("<br>")

    // shift()        删除数组最前面的元素
    arr.shift()
    for(let a of arr){
        document.write(a+" ")
    }
    document.write("<br>")

    // includes(元素) 判断数组是否包含给定的值
    document.write(arr.includes(5))
    document.write(arr.includes(10))
    document.write("<br>")

    // reverse()      反转数组中的元素
    arr.reverse()
    for(let a of arr){
        document.write(a+" ")
    }
    document.write("<br>")

    // sort()         对数组元素进行排序
    arr.sort()
    for(let a of arr){
        document.write(a+" ")
    }
    document.write("<br>")

</script>

Set
JavaScript中的Set集合, 元素唯一, 存取顺序一致

构造方法 说明
Set()    创建Set集合对象

成员方法     说明
add(元素)    向集合中添加元素
size属性     获取集合长度
keys()       获取迭代器对象
delete(元素) 删除指定元素

<script>
    // Set()    创建Set集合对象
    let s = new Set();

    // add(元素)    向集合中添加元素
    s.add("a")
    s.add("b")
    s.add("c")
    s.add("c")

    // size属性     获取集合长度
    document.write(s.size)
    document.write("<br>")

    // keys()       获取迭代器对象
    var st = s.keys();
    for(let i=0; i<s.size ; i++){
        document.write(st.next().value + " ")
    }
    document.write("<br>")

    // delete(元素) 删除指定元素
    s.delete("a")
    for(let sa of s){
        document.write(sa+" ")
    }
    document.write("<br>")

</script>

Map
- JavaScript的Map集合, key唯一, 存取顺序一致

构造方法 说明
Map()    创建Map集合对象

成员方法       说明
set(key,value) 向集合中添加元素
size属性       获取集合长度
get(key)       根据key获取value
entries()      获取迭代器对象
delete(key)    根据key删除键值对

<script>
    // Map()    创建Map集合对象
    let map = new Map()

    // set(key,value) 向集合中添加元素
    map.set("张三",23)
    map.set("王五",25)
    map.set("王五",26)

    // size属性       获取集合长度
    document.write(map.size)
    document.write("<br>")

    // get(key)       根据key获取value
    document.write(map.get("张三"))
    document.write("<br/>")

    // entries()      获取迭代器对象
    let st = map.entries()
    for(let i = 0; i< map.size ; i++){
        document.write(st.next().value+" ")
    }
    document.write("<br/>")



    // delete(key)    根据key删除键值对
    document.write(map.delete("张三"))
    document.write("<br/>")

    st = map.entries()
    for(let i = 0; i< map.size ; i++){
        document.write(st.next().value+" ")
    }
    document.write("<br/>")

</script>

JSON
- JSON(JavaScript Obect Notation): 是一种轻量级的数据交换格式
- 基于ECMAScript 规范的一个子集, 采用完全独立于编程语言的文本格式来存储和表示数据
- 乘法和清晰的层次结构舍不得JSON成为理想的数据交换语言. 易于人阅读和编写, 同时也晚于计算机解析和生成, 并有效提升网络传输效率.

成员方法       说明
stringfy(对象) 将指定对象黑的为json格式字符串
parse(字符串)  将指定json格式字符串解析成对象

<script>
    // 定义天气
    let weather = {
        city : "北京",
        date : "2088-08-08",
        wendu : "10~23",
        shidu : "22%"
    };

    // 1. 天气转换成JSON格式的字符串
    let str = JSON.stringify(weather)
    document.write(str)
    document.write("<br/>")

    // 2. 将JSON格式字符串解析成JS对象
    let weather2 = JSON.parse(str)
    document.write(weather2.city+" "+weather2.date+" "+weather2.wendu+" "+weather2.shidu)
    document.write("<br/>")

</script>

表单校验

<script>

    let dd = document.getElementById("regist")
    dd.onsubmit = check

    function check(){
        let username = document.getElementById("username").value

        let password = document.getElementById("password").value

        let nameRegx = /^[a-zA-Z]{4,16}$/
        let passwordRegx = /^[\d]{6}$/

        if( !nameRegx.test(username)){
            alert("用户名4-16位字母")
            return false
        }

        if(! passwordRegx.test(password)){
            alert("密码6位数字")
            return false
        }

        return true;
    }
</script>

BOM

BOM(Browser Object Model) 浏览器对象模型
将浏览器的各个组成部分封装成不同的对象, 方便我们进行操作

Window 窗口对象

定时器
- 唯一标识setTimeout(功能,毫秒值):设置一次性定时器.
- clearTimeout(标识):取消一次性定时器
- 唯一标识setInterval(功能,毫秒值):设置循环定时器
- clearInterval(标识):取消循环定时器
加载事件
- window.onload:在页面加载完毕后触发此事件的功能

<script>
    // 定时器
    function fun(){
        alert("该起床了")
    }


    // 设置一次性定时器
    let d1 = window.setTimeout("fun()",2000)
    window.clearTimeout(d1)

    // 设置循环定时器
    let d2 = window.setInterval("fun()", 3000)
    window.clearInterval(d2)


    // 加载事件
    window.onload = function (){
        let div = document.getElementById("div")
        alert(div)
    }
</script>

Location 地址栏对象

href 属性
- 就是浏览器的地址栏, 我们可以通过为该属性设置的新的URL, 使浏览器读取并显示新的URL的内容

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>location地址栏对象</title>
    <style>
        p{
            text-align: center;
        }
        span{
            color: red;
        }
    </style>
</head>
<body>
    <p>
        注册成功!<span id="time">5</span>秒之后自动跳转到首页...
    </p>
</body>
<script>

    let num = 5;
    function show(){
        num--;
        if(num<=0){
            location.href = "01-windows窗口对象.html"
        }

        let span = document.getElementById("time");
        span.innerHTML = num
    }

    window.setInterval("show()",1000)

</script>
</html>

图片显示

<body>

    <img src="dayanmiao3.png" id="img" alt="da" height="400px" style="display: none">
    <div class="login-form-wrap">
        <h1>黑马程序员</h1>
        <form class="login-form" action="#" id="regist" method="get" autocomplete="off">
            <label>
                <input type="text" id="username" name="username" placeholder="Username..." value="">
            </label>
            <label>
                <input type="password" id="password" name="password" placeholder="Password..." value="">
            </label>
            <input type="submit" value="注册">
        </form>
    </div>
</body>
<script>

    function hideImg(){
        let imgId = document.getElementById("img");
        imgId.setAttribute("style","display:none")
    }
    let sd1 = window.setTimeout(function(){
        let imgId = document.getElementById("img");
        imgId.setAttribute("style","display:block")
    },3000)
    let sd2 = window.setTimeout("hideImg()",6000)
</script>

封装

my.js

function getById(id){
    return document.getElementById(id);
}

function getByName(name){
    return document.getElementsByName(name);
}

function getByTag(tag){
    return document.getElementsByTagName(tag)
}

<script>
    // 效果是一样的
    let div2 = getById("div1")
    alert(div2)

    let arr2 = getByName("div2")
    alert(arr2.length)


    // let div1 = document.getElementById("div1")
    // alert(div1)
    //
    // let arr = document.getElementsByName("div2")
    // alert(arr.length)
</script>

JavaScript一 Li.066

Sun, 14 Nov 2021 15:51:02 +0800

JavaScript

JS的2种引入方式
- 直接在页面写
- 在页面引入

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>快速入门</title>
</head>
<body>
<button id="btn">点我呀</button>

<!--引入js的方式一: 内部方式-->
<script type="text/javascript">
    document.getElementById("btn").onclick = function (){
        alert("点我干嘛")
    }
</script>
<script src="js/my.js"></script>
</body>
</html>

输入输出语句

输入框
- prompt(“提示内容”);
弹出警告框
- alert(“提示内容”);
控制台输出
- console.log(“显示内容”);
页面内容输出
- document.write(“显示内容”);

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>输入输出语句</title>
</head>
<body>

<script>
    /*
    * 输入框
    * prompt("提示内容");
    * 弹出警告框
    * alert("提示内容");
    * 控制台输出
    * console.log("显示内容");
    * 页面内容输出
    * document.write("显示内容");
    */
    prompt("请输入数据")

    alert("hello")

    console.log("打印logo")

    document.write("DaDaDa...")
    document.write("<br/>")
    document.write("DaDa")
    document.write("<h1>Hello</h1>")
</script>
</body>
</html>

变量和常量

JavaScrip属于弱类型语言, 定义变量时不区分具体的数据类型
定义局部变量
- let 变量名 = 值
定义全局变量
- 变量名 = 值;
定义常量
- const 常量名= 值

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>变量和常量</title>
</head>
<body>
<script>
  // 1. 定义局部变量

  let name = "张三";
  let age = 23;
  document.write(name+", "+ age)
  document.write("<br/>")

  // 2. 定义全局变量
  {
      let l1 = "aa";
      l2 = "bb";
  }
  // document.writeln(l1)
  document.writeln(l2)
  document.write("<br/>")

  // 3. 定义常量
  const PI = 3.1415926
  // PI = 3.15
  document.write(PI)
</script>
</body>
</html>

原始数据类型

数据类型  说明
boolean   布尔类型,true或false
null      声明null值的声明关键字
undefined 代表变量未定义
number    整数或浮点数
string    字符串
bigint    大整数,例如let num=10n;

typeof用于判断变量的数据类型
- let age=18;
- document.write(typeof(age)); //number

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>typeof方法</title>
</head>
<body>
<script>
    let l1 = true
    document.write(typeof (l1))
    document.write("<br/>")

    let l2 = null
    document.write(typeof (l2))
    document.write("<br/>")

    let l3
    document.write(typeof (l3))
    document.write("<br/>")

    let l4 = 10
    document.write(typeof (l4))
    document.write("<br/>")

    let l5 = "hello"
    document.write(typeof (l5))
    document.write("<br/>")

    let l6 = 100n
    document.write(typeof (l6))
    document.write("<br/>")

</script>
</body>
</html>

算数运算符

算术运算符

运算符 说明
+      加法运算
-      减法运算
*      乘法运算
/      除法运算
%      取余数
++     自增
--     自减

赋值运算符

运算符 说明
=      将箱封号右边的值赋值给箱封号左边的变量
+=     想回后赋值
-=     相减后赋值
*=     相乘后赋值
/=     相除后赋值
%=     取余数后赋值

比较运算符

运算符 说明
== 判断值是否相等
=== 判断数据类型和值是否相等
> 大于
>= 大于等于
< 小于
<= 小于等于
!= 不等于

逻辑运算符

运算符 说明
&&     逻辑与,并且
||     逻辑或,或者
!      取反

三元运算符
- 三元运算符格式
  - (比较表达式)?表达式1:表达式2;
- 执行流程
  - 如果比较表达为true, 则取表达式1
  - 如果比较表达为false, 则取表达式2

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>运算符</title>
</head>
<body>
<script>
    let num = "10"
    // 和字符之间的+号, 拼接, 其他符号则把字符转成number运算
    document.write(num + 5)
    document.write("<br/>")
    document.write(num + "5")
    document.write("<br/>")
    document.write(num - 5)
    document.write("<br/>")
    document.write(num * 5)
    document.write("<br/>")

    let num2 = 10
    document.write(num == num2)
    document.write("<br/>")
    document.write(num === num2)
    document.write("<br/>")

</script>
</body>
</html>

JavaScrip的流程控制和循环语句

if
switch
for
while

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>流程控制和循环语句</title>
</head>
<body>
<script>
    // if 语句
    let month = 10
    if(month >= 3 && month <= 5){
        document.write("春季")
    } else if( month >= 6 && month <= 6){
        document.write("夏季")
    } else if( month >= 9 && month <= 11) {
        document.write("秋季")
    } else if( month == 12 || month == 1 || month == 2) {
        document.write("冬季")
    } else  {
        document.write("月份有误")
    }

    document.write("<br/>")

    // switch 语句
    switch (month){
        case 3:
        case 4:
        case 5:
            document.write("春季")
            break
        case 6:
        case 7:
        case 8:
            document.write("夏季")
            break
        case 9:
        case 10:
        case 11:
            document.write("秋季")
            break
        case 12:
        case 1:
        case 2:
            document.write("冬季")
            break
        default:
            document.write("月份有误")
    }

    document.write("<br/>")

    // for
    for(let i=1;i<=5;i++){
        document.write(i+"<br/>")
    }

    // while
    let n =6
    while (n <= 10){
        document.write(n+"<br/>")
        n++
    }
</script>
</body>
</html>

数组

数组的使用Java中的数据基本一致, 但是在JavaScript中的数据更加灵活, 数据类型和长度都没有限制
定义格式
- let 数组名 = [元素1,元素2,…];
索引范围
- 从0开始, 最大到数组长度-1
数组长度
- 数组名.length
数组高级运算符…
- 数组复制
- 合并数组
- 字符串转数组

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>数组</title>
</head>
<body>
<script type="text/javascript">
    // 定义数组
    let arr = [10,20,30]

    for(let i=0; i < arr.length; i++){
        document.write(arr[i])
        document.write("<br/>")
    }
    document.write("=======================<br/>")


    arr[3] = 40
    for(let i=0; i < arr.length; i++){
        document.write(arr[i])
        document.write("<br/>")
    }
    document.write("=======================<br/>")

    // 数组高级运算符: ...
    // 复制数组
    let arr2 = [...arr]

    for(let i=0; i < arr2.length; i++){
        document.write(arr2[i])
        document.write("<br/>")
    }
    document.write("=======================<br/>")

    // 合并数据
    let arr3 = [40,50,60];
    let arr4 = [...arr2,...arr3]
    for(let i=0; i < arr4.length; i++){
        document.write(arr4[i])
        document.write("<br/>")
    }

    for(var i of arr4){
        document.write(i)
        document.write("<br/>")
    }

    document.write("=======================<br/>")
    // 字符串转成数组
    let arr5 = [..."heima"]
    for(var i of arr5){
        document.write(i)
        document.write("<br/>")
    }

</script>
</body>
</html>

函数

函数类似于java中的方法, 可以将一些代码进行抽取, 达到复用的效果
定义格式
- function 方法名(参数列表){方法体 return 返回值}
- 有返回值, 可以写
- 无返回值, 则不需要写
可变参数
- function 方法名(…参数名){ 方法体; return 返回值 }
匿名函数
- function(参数列表){ 方法体; }

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>函数</title>
</head>
<body>
<script >
    // 无参无返回值的函数
    function println(){
        document.write("Hello JS"+"<br/>")
    }
    println()

    // 有参 有返回值方法
    function getSum(num1,num2){
        return num1 + num2;
    }
    let sum = getSum(10,20);
    document.write(sum+"<br/>")

    // 可变参数, 对n个数字进行求和
    function getSum(...params){
        let ss = 0
        for(let i=0; i <params.length; i++){
            ss+=params[i]
        }
        return ss;
    }
    let sum2 = getSum(10,20, 20)
    document.write(sum2)


    // 匿名函数
    let fun = function(){
        document.write("hello")
    }
    fun()
</script>

</body>
</html>

DOM

DOM(Document Object Model):文档对象模型
将HTML文档的各个组成部分, 封装为对象. 借助这些对象可以对HTML文档进行增删改查的动态操作
Document: 文档对象
- Element: 元素对象
  - Attribute: 属性对象
    - Text: 文本对象

方法名                              说明
getElementById(id属性值)            根据id获得一个元素
getElementsByTagName(标签名称)      根据标签名称获得多个元素
getElementsByName(name属性值)       根据name属性获得多个元素
getElementsByClassName(class属性值) 根据class属性获得多个元素
子元素对象.parentElement属性        获取当前元素的父元素

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>元素的操作</title>
    <style>
        .cls{
            border: 1px solid red;
        }
    </style>
</head>
<body>
<div id="div1">div1</div>
<div id="div2">div2</div>
<div class="cls">div3</div>
<div class="cls">div4</div>
<input type="text" name="username"/>

<script>
    // 1. getElementById(id属性值)            根据id获得一个元素
    var div1 = document.getElementById("div1");
    // alert(div1)
    console.log(div1.innerHTML)

    // 2. getElementsByTagName(标签名称)      根据标签名称获得多个元素
    var divs = document.getElementsByTagName("div");
    // alert(divs.length)
    for(var i of divs){
        console.log(i.innerHTML)
    }

    // 3. getElementsByName(name属性值)       根据name属性获得多个元素
    var nameEs = document.getElementsByName("username");
    alert(nameEs.length)
    for(let e of nameEs){
        console.log(e.getAttribute("type"))
    }

    // 4. getElementsByClassName(class属性值) 根据class属性获得多个元素
    var clsE = document.getElementsByClassName("cls");
    // alert(clsE.length)
    for(let e of clsE){
        console.log(e.innerHTML)
    }

    // 5. 子元素对象.parentElement属性        获取当前元素的父元素
    var parentElement = div1.parentElement;
    console.log(parentElement.tagName)

</script>
</body>
</html>

Element 元素的操作

方法名                      说明
createElement(标签名)       创建一个新元素
appendChild(子元素)         将指定子元素添加到父元素中
removeChild(子元素)         父元素删除指定子元素
replaceChild(新元素,旧元素) 用新元素替换子元素

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>元素的操作</title>
</head>
<body>
<select id="s">
    <option>---请选择---</option>
    <option>北京</option>
    <option>上海</option>
    <option>广州</option>
</select>

<script>
    // 1. createElement() 创建元素
    var sz = document.createElement("option");
    // 为option添加文本内容
    sz.innerHTML = "深圳"

    // 2. appendChild(子元素)         将指定子元素添加到父元素中
    var select = document.getElementById("s");
    select.appendChild(sz)

    // 3. removeChild(子元素)         父元素删除指定子元素
    // select.removeChild(sz)

    // 4. replaceChild(新元素,旧元素) 用新元素替换子元素
    var hz = document.createElement("option");
    hz.innerHTML = "杭州"
    select.replaceChild(cq,sz)

</script>
</body>
</html>

Attribute 属性的操作

方法名                      说明
setAtrribute(属性名,属性值) 设置属性
getAtrribute(属性名)        根据属性名获取属性值
removeAtrribute             根据属性名先锋队指定的属性
style属性                   为元素添加样式

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>属性的操作</title>
  <style>
    .acolor{
      color: #1c1ccb;
    }
  </style>
</head>
<body>
<a>点我呀</a>
<script>
    // 1. setAtrribute(属性名,属性值) 设置属性
    var a = document.getElementsByTagName("a")[0];
    a.setAttribute("href","https://baidu.com")

    // 2. getAtrribute(属性名)        根据属性名获取属性值
    var value = a.getAttribute("href");
    // alert(value)

    // 3. removeAtrribute             根据属性名先锋队指定的属性
    a.removeAttribute("href")

    // 4. style属性                   为元素添加样式
    // a.style.color = "red"

    // 5. className 属性 添加指定样式
    a.className = "acolor"

</script>
</body>
</html>

Text 文本的操作

属性名    说明
innerText 添加文本内容,不解析标签
innerHTML 添加文本内容,解析标签

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>文本的操作</title>
</head>
<body>

<div id="div"></div>
<script>
    // 1. innerText 添加文本内容, 不解析标签
    var div = document.getElementById("div");
    div.innerText = "<h1>这是div</h1>"

    // 2. innerHTML 添加文本内容, 解析标签
    div.innerHTML = "<h1>这也是DIV</h1>"
</script>
</body>
</html>

事件

事件指的就是当某些组件执行了某些操作后, 会触发某些代码的执行

事件名     说明
onload     某个页面或图像被完成加载
onsubmit   当表单提交时触发该事件
onclick    鼠标赣南事件
ondblclick 鼠标双击事件
onblur     元素失去售点
onfocus    元素获得售点
onchange   用户改变域的内容

了解的事件

事件名      说明
onkeydown   某个键盘的键被按下
onkeypress  某个键盘的键被按下或按住
onkeyup     某个键盘的键被松开
onmousedown 某个鼠标按钮被按下
onmouseup   某个鼠标按钮被李嘉琪
onmouseover 鼠标被移到某元素之上
onmouseout  鼠标从某元素移开

绑定事件

方式一
- 通过标签中的事件属性进行绑定
- button id=“btn” onclick=“执行的功能”>
方式二
- 通过DOM元素属性绑定
- document.getElementById(“btn”).onclick=执行的功能

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>事件</title>
</head>
<body>
<div align="center">
<img id="img" width="80%" height="800px" src="img/p1.jpg" />
<br/>
<button id="up" onclick="up()">上一张</button>
<button id="down">下一张</button>
</div>

<script>

    // var btnup = document.getElementById("up");

    var btndown = document.getElementById("down");

    function up(){
        let img = document.getElementById("img")
        img.setAttribute("src","img/p1.jpg")
    }

    function down(){
        let img = document.getElementById("img")
        img.setAttribute("src","img/p2.jpg")
    }

    btndown.onclick = down()

</script>
</body>
</html>

综合案例

appendChild
append支持添加多个Child了

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>综合案例</title>
    <style>

        a{
            color: blue;
        }
        table,table tr th, table tr td {
            border:1px solid black;
        }
    </style>
</head>
<body>
<div align="center">
    <div id="divinput" >
        <input type="text" id="name" placeholder="请输入姓名" autocomplete="off">
        <input type="text" id="age" placeholder="请输入年龄" autocomplete="off">
        <input type="text" id="gender" placeholder="请输入姓名" autocomplete="off" >
        <input type="button" id="add" value="添加" onclick="add()" >
    </div>
    <br/>
    <br/>
    <br/>
    <br/>
    <br/>
    <div >
        <a style="color: black;">学生信息表</a>
        <table style="width: 300px; border: 1px solid black" >
            <thead>
            <tr>
                <th>姓名</th>
                <th>年龄</th>
                <th>性别</th>
                <th>操作</th>
            </tr>
            </thead>
            <tbody id="tbody" >
            <tr>
                <td>张三</td>
                <td>23</td>
                <td>男</td>
                <td><a href="JavaScript:void(0);" onclick="deleteTr(this)">删除</a></td>
            </tr>
            <tr>
                <td>王五</td>
                <td>25</td>
                <td>女</td>
                <td><a href="JavaScript:void(0);"  onclick="deleteTr(this)">删除</a></td>
            </tr>
            </tbody>
        </table>
    </div>
</div>
<script>

    function deleteTr(obj){
        let tbody = obj.parentElement.parentElement.parentElement
        let tr = obj.parentElement.parentElement;
        tbody.removeChild(tr)
    }
    function add(){
        let tr = document.createElement("tr");

        let tdName = document.createElement("td");
        let tdAge = document.createElement("td");
        let tdGender = document.createElement("td");
        let tdDel = document.createElement("td");

        tr.appendChild(tdName)
        tr.appendChild(tdAge)
        tr.appendChild(tdGender)
        tr.appendChild(tdDel)

        let nameText = document.getElementById("name").value
        let ageText = document.getElementById("age").value
        let genderText = document.getElementById("gender").value

        tdName.innerText = nameText
        tdAge.innerText = ageText
        tdGender.innerText = genderText

        let a = document.createElement("a")
        let aText = document.createTextNode("删除")
        a.setAttribute("href","JavaScript:void (0);")
        a.setAttribute("onclick", "deleteTr(this)")
        a.appendChild(aText)
        tdDel.appendChild(a)

        let tbody = document.getElementById("tbody");

        tbody.appendChild(tr);

        // append 支持多参数了

        // let name = document.getElementById("name");
        // let age = document.getElementById("age");
        // let gender = document.getElementById("gender");
        //
        // let tr = document.createElement("tr");
        // let tdname = document.createElement("td");
        // tdname.innerText = name.value
        // let tdage = document.createElement("td");
        // tdage.innerText = age.value
        // let tdgender = document.createElement("td");
        // tdgender.innerText = gender.value
        //
        // let tddel = document.createElement("td");
        // tddel.innerHTML = "<a href=\"JavaScript:void(0);\" onclick=\"deleteTr()\">删除</a>"
        //
        // tr.append(tdname,tdage,tdgender,tddel);
        //
        // let tbody = document.getElementById("tbody");
        //
        // tbody.append(tr);
    }

</script>

</body>
</html>

MyBatis框架三 Li.065

Thu, 04 Nov 2021 21:59:16 +0800

注解开发MyBatis

操作
- 创建接口和查询方法
- 在核心配置文件中配置映射关系
- 编写测试类

package com.lizicai.mapper;

import com.lizicai.bean.Student;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.util.List;

public interface StudentMapper {

    // 查询
    @Select( "SELECT * FROM student")
    public abstract List<Student> selectAll();

    // 插入数据
    @Insert("INSERT INTO student VALUES (#{id},#{name},#{age})")
    public abstract Integer insert(Student stu);

    // 修改数据
    @Update("UPDATE student SET name=#{name},age=#{age} WHERE id=#{id}" )
    public abstract Integer update(Student stu);

    // 删除数据
    @Delete("DELETE FROM student WHERE id=#{id}")
    public abstract Integer delete(Integer id);
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTA Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--    数据库账号配置-->
    <properties resource="jdbc.properties"></properties>

<!--    配置log4j-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>


    <!-- 起别名 -->
    <typeAliases>
        <package name="com.lizicai.bean"/>
    </typeAliases>

    <!-- 集成分页助手插件 -->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>

    <environments default="mariadb">
        <environment id="mariadb">
            <!-- 事务管理, 默认采用JDBC默认的事务-->
            <transactionManager type="JDBC"></transactionManager>
<!--            dataSource数据源信息 type属性 连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
        <environment id="mariadb2">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="org.mariadb.jdbc.Driver"/>
                <property name="url" value="jdbc:mariadb://192.168.0.100:3306/db2"/>
                <property name="username" value="root"/>
                <property name="password" value="rootPassword"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
<!--        配置映射关系-->
        <package name="com.lizicai.mapper"/>
    </mappers>
</configuration>

package com.lizicai.test;

import com.lizicai.bean.Student;
import com.lizicai.mapper.StudentMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class Test01 {
    @Test
    public void selectAll() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        List<Student> list = mapper.selectAll();

        for(Student c : list){
            System.out.println(c);
        }
        sqlSession.close();

        is.close();
    }

    @Test
    public void insert() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        Student stu = new Student(9,"李大刀",20);

        Integer result = mapper.insert(stu);

        System.out.println(result);

        sqlSession.close();

        is.close();
    }

    @Test
    public void update() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        Student stu = new Student(9,"李大刀",22);

        Integer result = mapper.update(stu);

        System.out.println(result);

        sqlSession.close();

        is.close();
    }
    @Test
    public void delete() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        Integer result = mapper.delete(9);

        System.out.println(result);

        sqlSession.close();

        is.close();
    }
}

一对一

环境准备
@Results: 封装
环境准备
@Results：封装映射关系的父注解。
Result[] value() ：定义了Result 数组
@Result：封装映射关系的子注解。
- column 属性：查询出的表中字段名称
- property 属性：实体对象中的属性名称
- javalype 厲性：被包含对象的数据类型
- one 属性：一对—查询固定属性
@One：一对一查询的注解。
- select 属性：指定调用某个接口中的方法

public class Person {
    private Integer id;
    private String name;
    private Integer age;
}

public class Card {
    private Integer id;
    private String number;
    private Person p;
}

package com.lizicai.one_to_one;

import com.lizicai.bean.Card;
import com.lizicai.bean.Person;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface CardMapper {
    // 查询全部
    @Select("SELECT * FROM card")
    @Results({
            @Result(column = "id", property = "id"),
            @Result(column = "number",property = "number"),
            @Result(
                    property = "p",
                    javaType = Person.class,
                    column = "pid",
                    /**
                     * one @One 一对一固定写法
                     * select属性: 指定调用哪个接口中的哪个方法
                    */
                    one = @One(select = "com.lizicai.one_to_one.PersonMapper.selectById")
            )
    })
    public abstract List<Card> selectAll();
}

package com.lizicai.one_to_one;

import com.lizicai.bean.Person;
import org.apache.ibatis.annotations.Select;

public interface PersonMapper {

    // 根据id查询
    @Select("SELECT * FROM person WHERE id=#{id}")
    public abstract Person selectById(Integer id);
}

@Test
public void selectAll() throws IOException {
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);

    CardMapper mapper = sqlSession.getMapper(CardMapper.class);
    List<Card> list = mapper.selectAll();

    for (Card card : list) {
        System.out.println(card);
    }
    sqlSession.close();

    is.close();
}

MyBatisConfig.xml仍然要配置对应的mapper

    <mappers>
<!--        配置映射关系-->
        <package name="com.lizicai.one_to_one"/>
    </mappers>

一对多

环境准备
@Results：封装映射关系的父注解。 Result[] value() ：定义了 Result 数组
@Result ：封装映射关系的子注解。
- column 属性：查询出的表中字段名称
- property 厲性：实体对象中的属性名称
- javaType厲快：被包含对象的数据类型
- many 属性：一对多查询固定属性

public class Classes {
    private Integer id;
    private String name;

    private List<Student> students;
}

public class Student {
    private Integer id;
    private String name;
    private Integer age;
}

CREATE TABLE classes(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(20)
);
INSERT INTO classes VALUES (NULL, '一班');
INSERT INTO classes VALUES (NULL, '二班');

CREATE TABLE student(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(30),
    age INT,
    cid INT,
    CONSTRAINT cs_fk FOREIGN KEY (cid) REFERENCES classes(id)
);

INSERT INTO student VALUES (NULL,'张三',23,1);
INSERT INTO student VALUES (NULL,'李四',24,1);
INSERT INTO student VALUES (NULL,'王五',25,2);
INSERT INTO student VALUES (NULL,'赵六',26,2);

SELECT * FROM student;
SELECT * FROM classes;

package com.lizicai.one_to_many;

import com.lizicai.bean.Classes;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface ClassesMapper {

    @Select("SELECT * FROM classes")
    @Results({
            @Result(column = "id", property = "id"),
            @Result(column = "name",property = "name"),
            @Result(
                    property = "students",
                    javaType = List.class,
                    column = "id",
                    /**
                     * many @Many 一对一固定写法
                     * select属性: 指定调用哪个接口中的哪个方法
                    */
                    many = @Many(select = "com.lizicai.one_to_many.StudentMapper.selectByCid")
            )
    })
    public abstract List<Classes> selectAll();
}

package com.lizicai.one_to_many;

import com.lizicai.bean.Student;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface StudentMapper {

    @Select("SELECT * FROM student WHERE cid=#{cid}")
    public abstract List<Student> selectByCid(Integer cid);
}

@Test
public void selectAll() throws IOException {
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);

    ClassesMapper mapper = sqlSession.getMapper(ClassesMapper.class);

    List<Classes> list = mapper.selectAll();

    for (Classes c : list) {
        System.out.println(c.getId()+c.getName());
        List<Student> students = c.getStudents();
        if(students !=null){
            for (Student student : students) {
                System.out.println(student);
            }
        }
    }
    sqlSession.close();

    is.close();
}

<mappers>
    <!-- 配置映射关系-->
    <package name="com.lizicai.one_to_one"/>
    <package name="com.lizicai.one_to_many"/>
    <!-- <package name="com.lizicai"/> 也可-->
</mappers>

多对多

环境准备
@Results：封装映射关系的父注解。 Result[] value() ：定义了 Result 数组
@Result ：封装映射关系的子注解。
- column 属性：查询出的表中字段名称
- property 厲性：实体对象中的属性名称
- javaType厲快：被包含对象的数据类型
- many 属性：一对多查询固定属性
@Many: 一对多查询的注解
- select属性: 指定调用某个接口中的方法

CREATE TABLE course(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(20)
);
INSERT INTO course VALUES (NULL,'语文');
INSERT INTO course VALUES (NULL,'数学');

CREATE TABLE stu_cr(
    id INT PRIMARY KEY AUTO_INCREMENT,
    sid INT,
    cid INT,
    CONSTRAINT sc_fk1 FOREIGN KEY (sid) REFERENCES student(id),
    CONSTRAINT sc_fk2 FOREIGN KEY (cid) REFERENCES course(id)
);
INSERT INTO stu_cr VALUES (NULL,1,1);
INSERT INTO stu_cr VALUES (NULL,1,2);
INSERT INTO stu_cr VALUES (NULL,2,1);
INSERT INTO stu_cr VALUES (NULL,2,2);

SELECT * FROM course;
SELECT * FROM stu_cr;

<mappers>
        <!--  配置映射关系-->
        <package name="com.lizicai.one_to_one"/>
        <package name="com.lizicai.one_to_many"/>
        <package name="com.lizicai.many_to_many"/>
        <!-- <package name="com.lizicai"/> 也可-->
    </mappers>

package com.lizicai.many_to_many;

import com.lizicai.bean.Course;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface CourseMapper {

    @Select("SELECT c.id,c.name FROM stu_cr sc, course c WHERE  sc.cid = c.id AND sc.sid=#{id}")
    public abstract List<Course> selectBySid(Integer id);
}

package com.lizicai.many_to_many;

import com.lizicai.bean.Student;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface StudentCourseMapper {
    @Select("SELECT DISTINCT s.id,s.name,s.age FROM stu_cr sc, student s WHERE  sc.sid=s.id ;")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(column = "age",property = "age"),
            @Result(
                    property = "courses",
                    javaType = List.class,
                    column = "id",
                    many = @Many(select = "com.lizicai.many_to_many.CourseMapper.selectBySid")
            )
    })
    public abstract List<Student> selectAll();
}

@Test
public void selectAll() throws IOException {
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);

    StudentCourseMapper mapper = sqlSession.getMapper(StudentCourseMapper.class);

    List<Student> list = mapper.selectAll();

    for (Student stu : list) {
        System.out.println(stu.getId()+stu.getName());
        List<Course> courses = stu.getCourses();
        if(courses !=null){
            for (Course c : courses) {
                System.out.println(c);
            }
        }
    }
    sqlSession.close();

    is.close();
}

构建SQL语句

org.apache.ibatis.idbcSQL：构建SQL 语句的功能类。通过一些方法来代替SQL 语句的关键字。
- SELECTO
- FROMO
- WHEREO
- INSERT INTOO
- VALUESO
- UPDATEO
- DELETE FROMO
@SelectProvider : 生成查询用的SQL语句注解。
@InsertProvider : 生成新增用的SQL语句注解
@UpdateProvider : 生成修改用的SQL语句注解，
@DeleteProvider : 生成洲除用的SQL语句注解。
- type属性: 生成SQL语句功能类对象
- method属性: 指定调用方法

public class Student {
    private Integer id;
    private String name;
    private Integer age;

    private Integer cid;
}

package com.lizicai.sql;

import org.apache.ibatis.jdbc.SQL;

public class ReturnSql {

    public String getSelectAll(){
        return new SQL() {
            {
                SELECT("*");
                FROM("student");
            }
        }.toString();
    }

    public String getInsert(){
        return new SQL(){
            {
                INSERT_INTO("student");
//                VALUES("id,name,age,cid"," #{id},#{name},#{age},#{cid}");
                INTO_VALUES("#{id},#{name},#{age},#{cid}");
            }
        }.toString();
    }

    public String getUpdate(){
        return new SQL(){
            {
                UPDATE("student");
                SET("name=#{name}","age=#{age}");
                WHERE("id=#{id}");
            }
        }.toString();
    }

    public String getDelete(){
        return new SQL(){
            {
                DELETE_FROM("student");
                WHERE("id=#{id}");
            }
        }.toString();
    }
}

    <mappers>
        <!--  配置映射关系-->
         <package name="com.lizicai"/>
    </mappers>

package com.lizicai.mapper;

import com.lizicai.bean.Student;
import com.lizicai.sql.ReturnSql;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface StudentMapper {
//    @Select("SELECT * FROM student")
//    public abstract List<Student> selectAll();

    @SelectProvider(type = ReturnSql.class, method = "getSelectAll")
    public abstract List<Student> selectAll();

    @InsertProvider(type = ReturnSql.class, method = "getInsert")
    public abstract Integer insert(Student stu);

    @UpdateProvider(type = ReturnSql.class, method = "getUpdate")
    public abstract Integer update(Student stu);

    @DeleteProvider(type = ReturnSql.class, method = "getDelete")
    public abstract Integer delete(Integer id);
}

package com.lizicai.test;

import com.lizicai.bean.Student;
import com.lizicai.mapper.StudentMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class Test001 {
    @Test
    public void selectAll() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        List<Student> students = mapper.selectAll();

        for (Student stu : students) {
            System.out.println(stu);
        }

        sqlSession.close();

        is.close();
    }

    @Test
    public void insert() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        Student stu = new Student(5,"赵七",27,1);


        Integer result = mapper.insert(stu);

        System.out.println(result);
        sqlSession.close();

        is.close();
    }


    @Test
    public void update() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        Student stu = new Student(5,"赵七",17,1);


        Integer result = mapper.update(stu);

        System.out.println(result);
        sqlSession.close();

        is.close();
    }

    @Test
    public void delete() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        Integer result = mapper.delete(5);

        System.out.println(result);
        sqlSession.close();

        is.close();
    }
}

MyBatis框架二 Li.064

Wed, 03 Nov 2021 10:30:07 +0800

接口代理方式实现Dao层

接口代理方式-实现规则
- 传统方式实现Dao 层，我们既要写接口，还要与实现类。而MyBatis框架可以帮助我们省略编写 Dao 层接口实现类的步骤
- 程序员只需要编写接口，由MyBatis 框架根据接口的定义来创建该接口的动态代理对象。
实现规则
- 映射配置文件中的名称空间必须和 Dao 层接口的全类名相同。
- 映射配置文件中的增删改查标签的 id 属性必须和 Dao 层接口的方法名相同。
- 映射配置文件中的增删改查标签的 parameterType 属性必须和 Dao 层接口方法的参数相同。
- 映射配置文件中的增删改查标签的 resultType 属性必须和 Dao 层接口方法的返回值相同。
获取动态代理对象
- SqlSession功能类中的getMapper()方法

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTA Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
mapper: 核心根标签
namespace属性: 名称空间
-->
<mapper namespace="com.lizicai.mapper.StudentMapper">
<!--
    select: 查询功能的标签
    id属性: 唯一标识
    resultType属性: 指定结果映射对象类型
    parameterType属性: 指定参数映射对象类型
-->
    <select id="selectAll" resultType="student">
        SELECT * FROM student
    </select>

    <select id="selectById" resultType="student" parameterType="int">
        SELECT * FROM student WHERE id = #{id}
    </select>

    <insert id="insert" parameterType="student">
        INSERT INTO student VALUES (#{id},#{name},#{age})
    </insert>

    <update id="update" parameterType="student">
        UPDATE student SET name=#{name},age=#{age} WHERE id=#{id}
    </update>

    <delete id="delete" parameterType="int">
        DELETE FROM student WHERE id=#{id};
    </delete>
</mapper

package com.lizicai.service.impl;

import com.lizicai.bean.Student;
import com.lizicai.mapper.StudentMapper;
import com.lizicai.service.StudentService;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class StudentServiceImpl implements StudentService {

    // 查询全部
    @Override
    public List<Student> selectAll() {
        List<Student> list = null;
        InputStream is = null;
        SqlSession sqlSession = null;

        try{
            // 1. 加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");

            // 2. 获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

            // 3. 通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);

            // 4. 获取StudentMapper接口的实现类对象
            StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

            // 5. 通过实现类对象调用方法, 接收结果
            list = mapper.selectAll();

        }catch (IOException e){
            e.printStackTrace();
        } finally {
            // 6. 释放资源
            if( sqlSession != null){
                sqlSession.close();
            }
            if( is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

        // 7. 返回结果
        return list;
    }

    // 根据id查询
    @Override
    public Student selectById(Integer id) {
        Student stu = null;
        InputStream is = null;
        SqlSession sqlSession = null;

        try{
            // 1. 加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");

            // 2. 获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

            // 3. 通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);

            // 4. 获取StudentMapper接口的实现类对象
            StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

            // 5. 通过实现类对象调用方法, 接收结果
            stu = mapper.selectById(id);

        }catch (IOException e){
            e.printStackTrace();
        } finally {
            // 6. 释放资源
            if( sqlSession != null){
                sqlSession.close();
            }
            if( is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

        // 7. 返回结果
        return stu;
    }

    @Override
    public Integer insert(Student stu) {
        Integer result = null;
        InputStream is = null;
        SqlSession sqlSession = null;

        try{
            // 1. 加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");

            // 2. 获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

            // 3. 通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);

            // 4. 获取StudentMapper接口的实现类对象
            StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

            // 5. 通过实现类对象调用方法, 接收结果
            result = mapper.insert(stu);

        }catch (IOException e){
            e.printStackTrace();
        } finally {
            // 6. 释放资源
            if( sqlSession != null){
                sqlSession.close();
            }
            if( is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

        // 7. 返回结果
        return result;
    }

    @Override
    public Integer update(Student stu) {
        Integer result = null;
        InputStream is = null;
        SqlSession sqlSession = null;

        try{
            // 1. 加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");

            // 2. 获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

            // 3. 通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);

            // 4. 获取StudentMapper接口的实现类对象
            StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

            // 5. 通过实现类对象调用方法, 接收结果
            result = mapper.update(stu);

        }catch (IOException e){
            e.printStackTrace();
        } finally {
            // 6. 释放资源
            if( sqlSession != null){
                sqlSession.close();
            }
            if( is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

        // 7. 返回结果
        return result;
    }

    @Override
    public Integer delete(Integer id) {
        Integer result = null;
        InputStream is = null;
        SqlSession sqlSession = null;

        try{
            // 1. 加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");

            // 2. 获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

            // 3. 通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);

            // 4. 获取StudentMapper接口的实现类对象
            StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

            // 5. 通过实现类对象调用方法, 接收结果
            result = mapper.delete(id);

        }catch (IOException e){
            e.printStackTrace();
        } finally {
            // 6. 释放资源
            if( sqlSession != null){
                sqlSession.close();
            }
            if( is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

        // 7. 返回结果
        return result;
    }
}

动态SQL

动态SQL介绍
- MyBatis映射配置文件中, 前面SQL都是简单的, 有些业务逻辑复杂时, SQL是动态变化, 此时前面学习的SQL就不能满足要求了
多条件查询
- SELECT * FORM student WHERE id=? AND name=? AND age=?;
- SELECT * FORM student WHERE id=? AND name=?;
动态SQL标签
- : 条件判断标签
- : 循环遍历标签

    <select id="selectCondition" resultType="student" parameterType="student">
        SELECT * FROM student
        <where>
            <if test="id != null">
                id=#{id}
            </if>
            <if test="name != null">
                AND name=#{name}
            </if>
            <if test="age != null">
                AND age=#{age}
            </if>
        </where>
    </select>

 @Test
    public void selectCondition() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        Student stu = new Student();
//        stu.setId(2);
        stu.setName("李四");
        stu.setAge(24);

        List<Student> list = mapper.selectCondition(stu);

        for(Student student : list){
            System.out.println(student);
        }

        sqlSession.close();

        is.close();
    }

@Test
public void selectByIds() throws IOException{
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

    List<Integer> ids = new ArrayList<>();
    ids.add(1);
    ids.add(2);

    List<Student> list = mapper.selectByIds(ids);

    for(Student student : list){
        System.out.println(student);
    }

    sqlSession.close();

    is.close();
}

SQL 片段抽取

我们可以将一些重复的SQL语句进行抽取, 以达到复用的效果

<sql id="select">SELECT * FROM student</sql>

<select id="selectAll" resultType="student">
    <include refid="select"></include>
</select>

<select id="selectById" resultType="student" parameterType="int">
    <include refid="select"></include> WHERE id = #{id}
</select>

分页插件

企业开发中, 分页是常见技术. MyBatis是不带分页功能的, 如果想实现分页功能, 需要手动编写LIMIT语句.不同数据库实现分页SQL语句也是不同, 手写成本高.
PageHelper: 第三方分页助手, 将复杂的分页操作进行封装, 从而让分页功能变得非常简单.

分页插件实现步骤

导入包
在核心配置文件中集成分页助手插件
在测试类中使用分页助手相关API实现分页功能

分页插件实现步骤

导入pagehelper-5.1.10.jar, jsqlparser-3.1.jar包
- PageHelper下载
- jsqlparser下载
在核心配置文件中集成分页助手插件

<configuration>
    <!-- 集成分页助手插件 -->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>
</configuration>

在测试类中使用分页助手相关API实现分页功能

 @Test
    public void selectCondition() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        // 通过分页助手来实现分页功能
        // 第1页3条数据
//        PageHelper.startPage(1,3);

        // 第2页3条数据
//        PageHelper.startPage(2,3);

        // 第3页3条数据
        PageHelper.startPage(3,3);
        List<Student> list = mapper.selectAll();

        for(Student student : list){
            System.out.println(student);
        }

        sqlSession.close();

        is.close();
    }

分页插件相关参数

PageInfo: 封装分页相关参数的功能类
核心方法

返回值  方法名          说明
long    getTotal()      获取总条数
int     getPages()      获取总页数
int     getPageNum()    获取当前页
int     getPageSize()   获取每页显示条数
int     getPrePage()    获取上一页
int     getNextPage()   获取下一页
boolean isIsFirstPage() 获取是否是第一页
boolean isIsLastPage()  获取是否是最后一页

@Test
public void selectCondition() throws IOException {
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

    // 通过分页助手来实现分页功能
    // 第1页3条数据
//        PageHelper.startPage(1,3);

    // 第2页3条数据
//        PageHelper.startPage(2,3);

    // 第3页3条数据
    PageHelper.startPage(3,3);
    List<Student> list = mapper.selectAll();

    for(Student student : list){
        System.out.println(student);
    }

    // 获取页相关参数
    PageInfo<Student> info = new PageInfo<>(list);

    System.out.println("总条数"+info.getTotal());
    System.out.println("总页数"+info.getPages());
    System.out.println("当前页"+info.getPageNum());
    System.out.println("每页显示条数"+info.getPageSize());
    System.out.println("上一页"+info.getPrePage());
    System.out.println("下一页"+info.getNextPage());
    System.out.println("是否第1页"+info.isIsFirstPage());
    System.out.println("是否最后1页"+info.isIsLastPage());

    sqlSession.close();

    is.close();
}

一对一

resultMap: 配置字段和对象属性的映射关系标签
- id属性: 唯一标识
- type属性: 实体对象类型
id: 配置主键映射关系标签
result: 配置非主键映射关系标签
- column属性: 表中字段名称
- property属性: 实体对象变量名称
association: 配置被包含对象的映射关系标签
- property属性: 被包含对象的变量名
- javaType属性: 被包含对象的数据类型
一对一模型: 人和身份证, 一个人只有一个身份证

数据准备

CREATE DATABASE db2;
USE db2;
CREATE TABLE person(
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(20),
    age INT
);
INSERT INTO person VALUES (NULL,"张三",23);
INSERT INTO person VALUES (NULL,"李四",24);
INSERT INTO person VALUES (NULL,"王五",25);

SELECT * FROM person;

CREATE TABLE card(
    id INT PRIMARY KEY  AUTO_INCREMENT,
    number VARCHAR(30),
    pid INT,
    CONSTRAINT cp_fk FOREIGN KEY (pid) REFERENCES person(id)
);

INSERT INTO card VALUES (NULL,'12345',1);
INSERT INTO card VALUES (NULL,'22345',2);
INSERT INTO card VALUES (NULL,'32345',3);

public class Person {
    private Integer id;
    private String name;
    private Integer age;
    ...略
}

public class Card {
    private Integer id;
    private String number;
    private Person p;
    ...略
}

<mapper namespace="com.lizicai.table01.OneToOneMapper">
    <!-- 配置字段和实体对象属性的映射关系 -->
    <resultMap id="oneToOne" type="card">
        <id column="cid" property="id" />
        <result column="number" property="number" />

        <!-- 配置被包含对象的映射关系
           property 被包含的变量名
           javaType 被包含对象的数据类型
        -->
        <association property="p" javaType="person">
            <id column="pid" property="id" />
            <result column="name" property="name" />
            <result column="age" property="age" />
        </association>
    </resultMap>
    <select id="selectAll" resultMap="oneToOne">
        SELECT c.id cid,number,pid,NAME,age FROM card c, person p WHERE c.pid = p.id
    </select>
</mapper>

public interface OneToOneMapper {
    // 查询全部
    public abstract List<Card> selectAll();
}

package com.lizicai.table01;

import com.lizicai.bean.Card;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class Test01 {
    @Test
    public void selectAll() throws IOException {
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        OneToOneMapper mapper = sqlSession.getMapper(OneToOneMapper.class);

        List<Card> list = mapper.selectAll();

        for(Card c : list){
            System.out.println(c);
        }

        sqlSession.close();

        is.close();
    }
}

一对多

resultMap: 配置字段和对象属性的映射关系标签
- id属性: 唯一标识
- type属性: 实体对象类型
id: 配置主键映射关系标签
result: 配置非主键映射关系标签
- column属性: 表中字段名称
- property属性: 实体对象变量名称
collection: 配置被包含对象的映射关系标签
- property属性: 被包含对象的变量名
- ofType属性: 集合中保存的对象的数据类型
数据准备

CREATE TABLE classes(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(20)
);
INSERT INTO classes VALUES (NULL, '一班');
INSERT INTO classes VALUES (NULL, '二班');

CREATE TABLE student(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(30),
    age INT,
    cid INT,
    CONSTRAINT cs_fk FOREIGN KEY (cid) REFERENCES classes(id)
);

INSERT INTO student VALUES (NULL,'张三',23,1);
INSERT INTO student VALUES (NULL,'李四',24,1);
INSERT INTO student VALUES (NULL,'王五',25,2);
INSERT INTO student VALUES (NULL,'赵六',26,2);

SELECT * FROM student;
SELECT * FROM classes;

public class Classes {
    private Integer id;
    private String name;

    private List<Student> students;
    ...略
}

public class Student {
    private Integer id;
    private String name;
    private Integer age;
    ...略
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTA Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lizicai.table02.OneToManyMapper">
    <!-- 配置字段和实体对象属性的映射关系 -->
    <resultMap id="oneToMany" type="classes">
        <id column="cid" property="id" />
        <result column="cname" property="name" />

        <!-- collection: 配置被包含的集合对象映射关系
        property: 被包含对象的变量名
        ofType: 被包含对象的实际数据类型
        -->
        <collection property="students" ofType="student">
            <id column="sid" property="id" />
            <result column="sname" property="name" />
            <result column="sage" property="age" />
        </collection>

    </resultMap>
    <select id="selectAll" resultMap="oneToMany">
        SELECT c.id cid,c.NAME cname,s.id sid,s.NAME sname,s.age sage FROM classes c, student s WHERE c.id = s.cid;
    </select>
</mapper>

在MyBatisConfig.xml引入

<mappers>
<!--        引入指定的映射配置文件 resource属性指定映射配置文件的名称-->
    <mapper resource="com/lizicai/one_to_one/OneToOneMapper.xml" />
    <mapper resource="com/lizicai/one_to_many/OneToManyMapper.xml" />
</mappers>

package com.lizicai.table02;

import com.lizicai.bean.Classes;

import java.util.List;

public interface OneToManyMapper {
    // 查询全部
    public abstract List<Classes> selectAll();
}

@Test
public void selectAll() throws IOException {
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);

    OneToManyMapper mapper = sqlSession.getMapper(OneToManyMapper.class);

    List<Classes> list = mapper.selectAll();

    for(Classes cls : list){
        System.out.println(cls.getId()+cls.getName());
        for(Student stu : cls.getStudents()){
            System.out.println("\t"+stu);
        }
    }

    sqlSession.close();

    is.close();
}

多对多

多对多模型: 学生和课程, 一个学生可以选择多门课程, 一个课程也可以被多个学生所选择
数据准备

CREATE TABLE course(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(20)
);
INSERT INTO course VALUES (NULL,'语文');
INSERT INTO course VALUES (NULL,'数学');

CREATE TABLE stu_cr(
    id INT PRIMARY KEY AUTO_INCREMENT,
    sid INT,
    cid INT,
    CONSTRAINT sc_fk1 FOREIGN KEY (sid) REFERENCES student(id),
    CONSTRAINT sc_fk2 FOREIGN KEY (cid) REFERENCES course(id)
);
INSERT INTO stu_cr VALUES (NULL,1,1);
INSERT INTO stu_cr VALUES (NULL,1,2);
INSERT INTO stu_cr VALUES (NULL,2,1);
INSERT INTO stu_cr VALUES (NULL,2,2);

SELECT * FROM course;
SELECT * FROM stu_cr;

public class Course {
    private Integer id;
    private String name;
}

public class Student {
    private Integer id;
    private String name;
    private Integer age;

    private List<Course> courses;
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTA Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lizicai.table03.ManyToManyMapper">
    <!-- 配置字段和实体对象属性的映射关系 -->
    <resultMap id="manyToMany" type="student">
        <id column="sid" property="id" />
        <result column="sname" property="name" />
        <result column="sage" property="age" />

        <!-- collection: 配置被包含的集合对象映射关系
        property: 被包含对象的变量名
        ofType: 被包含对象的实际数据类型
        -->
        <collection property="courses" ofType="course">
            <id column="cid" property="id" />
            <result column="cname" property="name" />
        </collection>

    </resultMap>
    <select id="selectAll" resultMap="manyToMany">
        SELECT sc.sid,s.NAME sname,s.age sage,sc.cid cid,c.NAME cname
        FROM student s,course c,stu_cr sc WHERE sc.sid=s.id AND sc.cid=c.id;
    </select>
</mapper>

public interface ManyToManyMapper {
    // 查询全部
    public abstract List<Student> selectAll();
}

@Test
public void selectAll() throws IOException {
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);

    ManyToManyMapper mapper = sqlSession.getMapper(ManyToManyMapper.class);

    List<Student> students = mapper.selectAll();

    for(Student stu : students){
        System.out.println(stu.getId()+stu.getName()+stu.getAge());
        for(Course c : stu.getCourses()){
            System.out.println("\t"+c);
        }
    }

    sqlSession.close();

    is.close();
}

多对多

resultMap: 配置字段和对象属性的映射关系标签
- id属性: 唯一标识
- type属性: 实体对象类型
id: 配置主键映射关系标签
result: 配置非主键映射关系标签
- column属性: 表中字段名称
- property属性: 实体对象变量名称
collection: 配置被包含对象的映射关系标签
- property属性: 被包含对象的变量名
- ofType属性: 集合中保存的对象的数据类型

MyBatis框架一 Li.063

Fri, 29 Oct 2021 14:45:49 +0800

MyBatis 介绍

MyBatis 是一个优秀的基于Java 的特久层框架，它内部封装了JDBC，使开发者只需要关注SQL语句本身，而不需要花费精力去处理加载驱动、创建连接、创建执行者等复杂的操作。
MyBatis通过xml 或注解的方式将要执行的各种Statement 配置起来，并通过Java对象和 Statement中 SQL 的动态参数进行映射生成最终要执行的SQL 语句。
最后MyBatis 框架执行完 SQL 并将结果映射为 Java 对象并返回。采用ORM 思想解决了实体和数据库映射的问题，对JDBC 进行了封装，屏蔽了 JDBC API 底层访问细节，使我们不用与JDBC API打交道，就可以完成对数据库的持久化操作。

MyBatis 使用示例

导入mariadb-java-client-2.7.4.jar和mybatis-3.5.7.jar

CREATE DATABASE db1;
use db1;
create table student(
   id int auto_increment primary key ,
   NAME VARCHAR(20),
   age int
);
INSERT INTO student VALUES
(null,'张三',23),(null,'李四',24),(null,'王五',25);

public class Student {
    private Integer id;
    private String name;
    private Integer age;
    ...略
}

package com.lizicai.dao;

import com.lizicai.bean.Student;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class StudentTest01 {
    /**
     * 查询全部
     */
    public static void main(String[] args) throws IOException {
        StudentTest01 s = new StudentTest01();
        s.selectAll() ;
    }
    public void selectAll() throws IOException {
        // 1. 加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        // 2.获取sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        // 3.获取sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 4. 获取执行结果
        List<Student>  list = sqlSession.selectList("StudentMapper.selectAll");

        // 5.打印结果
        for(Student stu : list){
            System.out.println(stu);
        }

        // 6. 关闭资源
        sqlSession.close();
        is.close();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTA Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="mariadb">
        <environment id="mariadb">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="org.mariadb.jdbc.Driver"/>
                <property name="url" value="jdbc:mariadb://192.168.0.100:3306/db1"/>
                <property name="username" value="root"/>
                <property name="password" value="rootPassword"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="StudentMapper.xml" />
    </mappers>
</configuration>

MyBatis 相关API

Resources: org.apache.ibatis.io.Resources
核心方法

返回值      方法名                               说明
InputStream getResourceAsStream(String.fileName) 通过类加载器返回指定资源的字节输入流

SqlSessionFactoryBuilder: org.apache.ibatis.session.SqlSessionFactoryBuilder 获取SqlSessionFactory工厂对象的功能类
核心方法

返回值            方法名                说明
SqlSessionFactory build(InputStream.is) 通过指定资源字节输入流获取SqlSession工厂对象

SqlSessionFactory: org.apache.ibatis.session.SqlSessionFactory: 获取SqlSession构建者对象的工厂接口
核心方法

返回值 方法名 说明
SqlSession openSession() 获取SqlSession构建对象,并开户手动提交事务
SqlSession openSession(boolean.autoCommit) 获取SqlSession构建者对象,如果参数为true,则开户自动提交事务

SqlSession: org.apache.ibatis.session.SqlSession 构建者对象接口. 用于执行SQL, 管理事务, 接口代理.

返回值  方法名                                       说明
List<E> selectList(String.statement,Object.paramter) 执行查询语句,返回List集合
T       selectOne(String.statement,Object.paramter)  执行查询语句,返回一个结果对象
int     insert(String.statement,Object.paramter)     执行新增语句,返回影响行数
int     update(String.statement,Object.paramter)     执行修改语句,返回影响行数
int     delete(String.statement,Object.paramter)     执行删除语句,返回影响行数
void    commit()                                     提交事务
void    rollback()                                   回滚事务
T       getMapper(Class<T>.cls)                      获取指定接口的代理实现类对象
void    close()                                      释放资源

public class Student { private Integer id; private String name; private Integer age;

public Student(){}

public Student(Integer id, String name, Integer age) {
    this.id = id;
    this.name = name;
    this.age = age;
}
...get set略...

}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTA Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
mapper: 核心根标签
namespace属性: 名称空间
-->
<mapper namespace="StudentMapper">
<!--
    select: 查询功能的标签
    id属性: 唯一标识
    resultType属性: 指定结果映射对象类型
    parameterType属性: 指定参数映射对象类型
-->
    <select id="selectAll" resultType="com.lizicai.bean.Student">
        SELECT * FROM student
    </select>

    <select id="selectById" resultType="com.lizicai.bean.Student" parameterType="java.lang.Integer">
        SELECT * FROM student WHERE id = #{id}
    </select>

    <insert id="insert" parameterType="com.lizicai.bean.Student">
        INSERT INTO student VALUES (#{id},#{name},#{age})
    </insert>

    <update id="updateById" parameterType="com.lizicai.bean.Student">
        UPDATE student SET name=#{name},age=#{age} WHERE id=#{id}
    </update>

    <delete id="deleteById" parameterType="java.lang.Integer">
        DELETE FROM student WHERE id=#{id};
    </delete>
</mapper>

package com.lizicai.dao;

import com.lizicai.bean.Student;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.io.InputStream;
import java.lang.invoke.SwitchPoint;
import java.util.List;

public class StudentTest01 {
    /**
     * id查询
     */

    @Test
    public void selectById() throws IOException {

        // 1. 加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        // 2.获取sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        // 3.获取sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        Student stu = sqlSession.selectOne("StudentMapper.selectById",1);

        System.out.println(stu);
        sqlSession.close();
        is.close();
    }

    /**
     * 更新用户信息
     */

    @Test
    public void updateById() throws IOException {
        // 1. 加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        // 2.获取sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        // 3.获取sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 4. 获取执行结果
        Student stu = new Student(2,"张三",24);
        int update = sqlSession.update("StudentMapper.updateById", stu);
        sqlSession.commit();
        System.out.println(update);
        sqlSession.close();
        is.close();
    }


    /**
     * 插入数据
     * @throws IOException
     */
    @Test
    public void insert() throws IOException {

        // 1. 加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        // 2.获取sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        // 3.获取sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        Student stu = new Student(4,"赵六",26);

        int insert = sqlSession.insert("StudentMapper.insert", stu);

        sqlSession.commit();

        System.out.println(insert);

        // 6. 关闭资源
        sqlSession.close();
        is.close();
    }
    /**
     * 删除数据
     */

    @Test
    public void delete() throws IOException {
        // 1. 加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        // 2.获取sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        // 3.获取sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        int delete = sqlSession.delete("StudentMapper.deleteById", 4);

        System.out.println(delete);

        sqlSession.commit();

        sqlSession.close();
        is.close();

    }

    /**
     * 查询全部
     */
    @Test
    public void selectAll() throws IOException {
        // 1. 加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        // 2.获取sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        // 3.获取sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 4. 获取执行结果
        List<Student>  list = sqlSession.selectList("StudentMapper.selectAll");

        // 5.打印结果
        for(Student stu : list){
            System.out.println(stu);
        }

        // 6. 关闭资源
        sqlSession.close();
        is.close();
    }
}

引入数据库连接配置

jdbc.properties

driver=org.mariadb.jdbc.Driver
url=jdbc:mariadb://192.168.0.100:3306/db1
username=root
password=rootPassword

MyBatisConfig.xml

<configuration>
    <properties resource="jdbc.properties"></properties>
    <environments default="mariadb">
        <environment id="mariadb">
            <!-- 事务管理, 默认采用JDBC默认的事务-->
            <transactionManager type="JDBC"></transactionManager>
<!--            dataSource数据源信息 type属性 连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
            <mappers>
<!--        引入指定的映射配置文件 resource属性指定映射配置文件的名称-->
        <mapper resource="StudentMapper.xml" />
    </mappers>
</configuration>

起别名

<configuration>
    <properties resource="jdbc.properties"></properties>

    <!-- 起别名 -->
     <typeAliases>
        <typeAlias type="com.lizicai.bean.Student" alias="student"></typeAlias>
        <package name="com.lizicai.bean"/>
    </typeAliases>

    <environments default="mariadb">
        <environment id="mariadb">
            <!-- 事务管理, 默认采用JDBC默认的事务-->
            <transactionManager type="JDBC"></transactionManager>
<!--            dataSource数据源信息 type属性 连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
            <mappers>
<!--        引入指定的映射配置文件 resource属性指定映射配置文件的名称-->
        <mapper resource="StudentMapper.xml" />
    </mappers>
</configuration>

<select id="selectAll" resultType="student">
    SELECT * FROM student
</select>
<select id="selectById" resultType="com.lizicai.bean.Student" parameterType="int">
    SELECT * FROM student WHERE id = #{id}
</select>

常见别名

别名    数据类型
string  java.lang.String
long    java.lang.Long
int     java.lang.Integer
double  java.lang.Double
boolean java.lang.Boolean

dao层实现

package com.lizicai.mapper;

import com.lizicai.bean.Student;

import java.util.List;

public interface StudentMapper {
    // 查询全部
    public abstract List<Student> selectAll();

    // 根据id查询
    public abstract Student selectById(Integer id);

    // 新增数据
    public abstract Integer insert(Student stu);

    // 修改数据
    public abstract Integer update(Student stu);

    // 删除数据
    public abstract Integer delete(Integer id);
}

package com.lizicai.mapper.impl;

import com.lizicai.bean.Student;
import com.lizicai.mapper.StudentMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class StudentMapperImpl implements StudentMapper {
    // 查询所有学生
    @Override
    public List<Student> selectAll() {
        List<Student> list =null;
        InputStream is = null;
        SqlSessionFactory sqlSessionFactory = null;
        SqlSession sqlSession = null;

        try {
            is = Resources.getResourceAsStream("MyBatisConfig.xml");

            sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

            sqlSession = sqlSessionFactory.openSession();

            list = sqlSession.selectList("StudentMapper.selectAll");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if( is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if( sqlSession != null){
                sqlSession.close();
            }
        }

        return list;
    }

    // 根据id查询
    @Override
    public Student selectById(Integer id) {
        Student stu = null;
        InputStream is = null;
        SqlSessionFactory sqlSessionFactory = null;
        SqlSession sqlSession = null;

        try {
            is = Resources.getResourceAsStream("MyBatisConfig.xml");

            sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

            sqlSession = sqlSessionFactory.openSession();

            stu = sqlSession.selectOne("StudentMapper.selectById",id);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if( is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if( sqlSession != null){
                sqlSession.close();
            }
        }

        return stu;
    }

    // 新增数据
    @Override
    public Integer insert(Student stu) {
        Integer result = null;

        InputStream is = null;
        SqlSessionFactory sqlSessionFactory = null;
        SqlSession sqlSession = null;

        try {
            is = Resources.getResourceAsStream("MyBatisConfig.xml");

            sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

            sqlSession = sqlSessionFactory.openSession();

            result = sqlSession.insert("StudentMapper.insert", stu);

            sqlSession.commit();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if( is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if( sqlSession != null){
                sqlSession.close();
            }
        }
        return result;
    }

    // 新增数据
    @Override
    public Integer update(Student stu) {
        Integer result = null;
        InputStream is = null;
        SqlSessionFactory sqlSessionFactory = null;
        SqlSession sqlSession = null;

        try {
            is = Resources.getResourceAsStream("MyBatisConfig.xml");

            sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

            sqlSession = sqlSessionFactory.openSession();

            result = sqlSession.update("StudentMapper.updateById", stu);

            sqlSession.commit();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if( is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if( sqlSession != null){
                sqlSession.close();
            }
        }

        return result;
    }

    // 删除数据
    @Override
    public Integer delete(Integer id) {
        Integer result = null;

        InputStream is = null;
        SqlSessionFactory sqlSessionFactory = null;
        SqlSession sqlSession = null;

        try {
            is = Resources.getResourceAsStream("MyBatisConfig.xml");

            sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

            // 默认提交事务提交
            sqlSession = sqlSessionFactory.openSession(true);

            result = sqlSession.delete("StudentMapper.deleteById", id);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if( is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if( sqlSession != null){
                sqlSession.close();
            }
        }

        return result;
    }
}

package com.lizicai.service;

import com.lizicai.bean.Student;

import java.util.List;

public interface StudentService {
    List<Student> selectAll();

    // 根据id查询
    Student selectById(Integer id);

    // 新增数据
    Integer insert(Student stu);

    // 修改数据
    Integer update(Student stu);

    // 删除数据
    Integer delete(Integer id);
}

package com.lizicai.service.impl;

import com.lizicai.bean.Student;
import com.lizicai.mapper.StudentMapper;
import com.lizicai.mapper.impl.StudentMapperImpl;
import com.lizicai.service.StudentService;

import java.util.List;

public class StudentServiceImpl implements StudentService {

    private StudentMapper mapper = new StudentMapperImpl();

    // 查询全部
    @Override
    public List<Student> selectAll() {
        return mapper.selectAll();
    }

    // 根据id查询
    @Override
    public Student selectById(Integer id) {
        return mapper.selectById(id);
    }

    @Override
    public Integer insert(Student stu) {
        return mapper.insert(stu);
    }

    @Override
    public Integer update(Student stu) {
        return mapper.update(stu);
    }

    @Override
    public Integer delete(Integer id) {
        return mapper.delete(id);
    }
}

package com.lizicai.controller;

import com.lizicai.bean.Student;
import com.lizicai.service.StudentService;
import com.lizicai.service.impl.StudentServiceImpl;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.List;

public class StudentController {
    // 创建业务层对象
    private StudentService service = new StudentServiceImpl();

    // 查询全部功能测试
    @Test
    public void selectAll(){
        List<Student> list = service.selectAll();
        for(Student stu : list){
            System.out.println(stu);
        }
    }

    // 根据id查询学生
    @Test
    public void selectById(){
        Student stu = service.selectById(1);
        System.out.println(stu);
    }

    // 新增学生
    @Test
    public void insert(){
        Student stu = new Student(4,"赵六",26);
        Integer insert = service.insert(stu);
        System.out.println(insert);
    }

    //  更新学生信息
    @Test
    public void update(){
       Student stu = new Student(3,"王五五",25);
       int update = service.update(stu);
        System.out.println(update );
    }

    //删除学生信息
    @Test
    public void delete(){
        int delete = service.delete(4);
        System.out.println(delete);
    }
}

LOG4J

下载log4j-1.2.17.jar版本

加入libs中

在MyBatisConfig.xml中引用log4j

<configuration>
<!--    数据库账号配置-->
    <properties resource="jdbc.properties"></properties>

<!--    配置log4j-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>
<configuration>

log4j.properties

# Global logging configuration
# ERROR WARN INFO DEBUG
log4j.rootLogger=DEBUG, stdout
#Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

JDBC数据库连接三 Li.062

Wed, 27 Oct 2021 17:31:17 +0800

自定义JDBC框架

使用JDBC过程中有大量的重复代码, 核心功能仅仅执行一条SQL语句, 所以可以抽取一个JDBC模板类, 来封装一些方法(update query).
专门帮我们执行增删改查SQL语句. 将之前那些重复的操作, 都抽取到模板类中的方法里, 就能大简化使用步骤

源信息

DataeBaseMetaData: 数据库的源信息
java.sql.DataBaseMetaData 封装了整个数据库的综合信息
- 例如 String getDatabaseProductName(): 获取数据库产品的名称
- 例如int getDatabaseProductVersion: 获取数据库产品的版本号
ParameterMetaData: 参数源信息
- java.sql.ParameterMetaData 封装的是预编译执行者对象中每个参数的类型和属性, 这个对象可以通过预编译执行者对象中的getParameterMetaData()方法来获取
- int getParameterCount() 用于获取SQL语句中的参数个数
ResultSetMetaData: 结果集的源信息
- java.sql.ResultSetMetaData: 封装的是结果集对象中列的类型和属性, 这个对象可以通过结果集对象中的getMetaData()方法来获取
- int getColumnCount() 用于获取列的总数, String getColumnName(int i)用于获取列名

package com.test005;

import com.lizicai.utils.DataSourceUtils;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.*;

public class JDBCTemplate {
    // 1. 定义参数变量(数据源, 连接对象, 执行者对象, 结果集对象
    private DataSource dataSource;
    private Connection con;
    private PreparedStatement pst;
    private ResultSet rs;

//    2. 通过有参构造为数据源赋值
    public JDBCTemplate(DataSource dataSource){
        this.dataSource = dataSource;
    }

//    3. 定义update方法, 参数 sql语句 sql语句中的参数

    public int update(String sql, Object... objs){
        int result = 0;

        try {
            con = dataSource.getConnection();

            pst = con.prepareStatement(sql);

            ParameterMetaData parameterMetaData = pst.getParameterMetaData();

            int count = parameterMetaData.getParameterCount();

            if( count != objs.length){
                throw new RuntimeException("参数个数不匹配");
            }

            for(int i=0; i< objs.length;i++){
                pst.setObject(i+1,objs[i]);
            }

            result = pst.executeUpdate();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DataSourceUtils.close(con, pst);
        }

        return  result;
    }
}

package com.test005;

import com.lizicai.utils.DataSourceUtils;
import org.junit.Test;

public class JDBCTemplateTest1 {
    private JDBCTemplate template = new JDBCTemplate(DataSourceUtils.getDataSource());

    @Test
    public void insert(){
        String sql = "INSERT INTO student VALUES (?,?,?,?)";
        Object[] params = {5,"周七",27,"1997-07-07"};
        int result = template.update(sql, params);
        if(result != 0){
            System.out.println("添加成功");
        } else {
            System.out.println("添加失败");
        }
    }

    @Test
    public void update(){
        String sql = "UPDATE student SET age=? WHERE name=?";
        Object[] params = {37,"周七"};
        int result = template.update(sql, params);
        System.out.println(result);
    }

    @Test
    public void delete(){
        String sql = "DELETE FROM student where name=?";
        Object[] params = {"周七"};
        int result = template.update(sql, params);
        System.out.println(result);
    }
}

查询功能-框架编写

查询一条记录并封装对象的方法: queryForObject()
查询多条记录并封装集合的方法: queryForList()
查询聚合函数并返回单条数据的方法: queryForScalar()
实体类的编写
- 定义一个类, 提供一些成员变量( 成员变量的数据类型和表中的列保持一致)

package com.test005.domain;

import java.util.Date;

public class Student {
    private Integer sid;
    private String name;
    private Integer age;
    private Date birthday;
    // get set constructor 略
}

package com.test005.handler;

import java.sql.ResultSet;

public interface ResultSetHandler<T> {
    <T> T handler(ResultSet rs);
}

package com.test005.handler;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;

// 1. 定义一个类, 实现ResultSetHandler 接口
public class BeanHandler<T> implements ResultSetHandler<T> {
//    2. 定义Class对象类型变量
    private Class<T> beanClass;

//    3. 通过有参构造为变量赋值
    public BeanHandler(Class<T> beanClass){
        this.beanClass = beanClass;
    }

//    4. 重写handler方法, 用于将一条记录封装到自定义对象中
    @Override
    public  T handler(ResultSet rs) {
        // 5. 声明自定义对象类型
        T bean = null;

        try {
            // 6. 创建传递参数的对象, 为自定义对象赋值
            bean =  beanClass.newInstance();

            // 7. 判断结果集中是否有数据
            if(rs.next()){
                // 8. 通过结果集对象获取结果集源信息的对象
                ResultSetMetaData metaData = rs.getMetaData();

                // 9. 通过结果集源信息对象获取列数
                int count = metaData.getColumnCount();

                // 10. 通过循环遍历列数
                for(int i=1;i<= count;i++){
                    // 11. 通过结果集源信息对象获取列名
                    String columnName = metaData.getColumnName(i);

                    // 12. 通过列名获取该列的数据
                    Object value = rs.getObject(columnName);

                    // 13. 创建属性描述器对象, 将获取到的值通过该对象的set方法进行赋值
                    PropertyDescriptor pd = new PropertyDescriptor
                            (columnName.toLowerCase(), beanClass);
                    Method writeMethod = pd.getWriteMethod();
                    writeMethod.invoke(bean, value);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 14. 返回封装好的对象
        return bean;
    }
}

 public <T> T queryForObject(String sql, ResultSetHandler<T> rsh, Object...objs){
        T obj = null;

        try {
            con = dataSource.getConnection();

            pst = con.prepareStatement(sql);

            ParameterMetaData parameterMetaData = pst.getParameterMetaData();

            int count = parameterMetaData.getParameterCount();

            if( count != objs.length){
                throw new RuntimeException("参数个数不匹配");
            }

            for(int i=0; i< objs.length;i++){
                pst.setObject(i+1,objs[i]);
            }

            rs = pst.executeQuery();

            obj = rsh.handler(rs);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DataSourceUtils.close(con, pst);
        }

        return  obj;
    }

@Test
public void queryForObject(){
    String sql = "SELECT * FROM student WHERE sid=?";
    Student stu = template.queryForObject(sql, new BeanHandler<>(Student.class), 1);
    System.out.println(stu);
}

查询列表

package com.test005.handler;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;

// 1. 定义一个类, 实现ResultSetHandler 接口
public class BeanListHandler<T> implements ResultSetHandler<T> {
//    2. 定义Class对象类型变量
    private Class<T> beanClass;

//    3. 通过有参构造为变量赋值
    public BeanListHandler(Class<T> beanClass){
        this.beanClass = beanClass;
    }

//    4. 重写handler方法, 用于将一条记录封装到自定义对象中
    @Override
    public List<T> handler(ResultSet rs) {
        // 5. 创建集合对象
        List<T> beanList = new ArrayList<>();

        try {

            // 6. 循环判断是否有值
            while (rs.next()){
                // 7. 创建传递参数的对象, 为自定义对象赋值
                T bean =  beanClass.newInstance();
                // 8. 通过结果集对象获取结果集源信息的对象
                ResultSetMetaData metaData = rs.getMetaData();

                // 9. 通过结果集源信息对象获取列数
                int count = metaData.getColumnCount();

                // 10. 通过循环遍历列数
                for(int i=1;i<= count;i++){
                    // 11. 通过结果集源信息对象获取列名
                    String columnName = metaData.getColumnName(i);

                    // 12. 通过列名获取该列的数据
                    Object value = rs.getObject(columnName);

                    // 13. 创建属性描述器对象, 将获取到的值通过该对象的set方法进行赋值
                    PropertyDescriptor pd = new PropertyDescriptor
                            (columnName.toLowerCase(), beanClass);
                    Method writeMethod = pd.getWriteMethod();
                    writeMethod.invoke(bean, value);
                }
                beanList.add(bean);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 14. 返回封装好的对象
        return beanList;
    }
}

/**
 * 查询多条记录
 */
public <T> List<T> queryListForObject(String sql, ResultSetHandler<T> rsh, Object...objs){
    List<T> list = new ArrayList<>();

    try {
        con = dataSource.getConnection();

        pst = con.prepareStatement(sql);

        ParameterMetaData parameterMetaData = pst.getParameterMetaData();

        int count = parameterMetaData.getParameterCount();

        if( count != objs.length){
            throw new RuntimeException("参数个数不匹配");
        }

        for(int i=0; i< objs.length;i++){
            pst.setObject(i+1,objs[i]);
        }

        rs = pst.executeQuery();

        list = rsh.handler(rs);

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        DataSourceUtils.close(con, pst);
    }

    return  list;
}

@Test
public void queryForList(){
    String sql = "SELECT * FROM student";
    List<Student> list = template.queryListForObject(sql, new BeanListHandler<>(Student.class));
    for(Student stu : list){
        System.out.println(stu);
    }
}

查询聚合函数

package com.test005.handler;

import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;

/**
 * 1. 定义一个类, 实现ResultSetHandler接口
 * 2. 我一定handler方法
 * 3. 定义一个Long类型变量
 * 4. 判断结果集对象中是否还有数据
 * 5. 获取结果集源信息的对象
 * 6. 获取第一列的列名
 * 7. 根据列名获取该列的值
 * 8. 返回结果
 */
// * 1. 定义一个类, 实现ResultSetHandler接口
public class ScalarHandler <T> implements ResultSetHandler<T>{

    //2. 我一定handler方法
    @Override
    public Long handler(ResultSet rs) {
        // 3. 定义一个Long类型变量
        Long value = null;

        try {
            // 4. 判断结果集对象中是否还有数据
            if(rs.next()){
                // 5. 获取结果集源信息的对象
                ResultSetMetaData metaData = rs.getMetaData();

                //6. 获取第一列的列名
                String columnName = metaData.getColumnName(1);
                // 7. 根据列名获取该列的值
                value = rs.getLong(columnName);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return value;
    }
}

/**
 *  聚合聚合函数的查询结果
 */
public Long queryForScalar(String sql, ResultSetHandler<Long> rsh, Object...objs){
    Long value = null;

    try {
        con = dataSource.getConnection();

        pst = con.prepareStatement(sql);

        ParameterMetaData parameterMetaData = pst.getParameterMetaData();

        int count = parameterMetaData.getParameterCount();

        if( count != objs.length){
            throw new RuntimeException("参数个数不匹配");
        }

        for(int i=0; i< objs.length;i++){
            pst.setObject(i+1,objs[i]);
        }

        rs = pst.executeQuery();

        value = rsh.handler(rs);

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        DataSourceUtils.close(con, pst);
    }

    return  value;
}

@Test
public void queryForScalar(){
    String sql = "SELECT COUNT(*) FROM student";

    Long value = template.queryForScalar(sql, new ScalarHandler<Long>());
    System.out.println(value);
}

JDBC数据库连接二 Li.061

Tue, 26 Oct 2021 18:21:18 +0800

数据库连接池

数据库连接池
- 数据库连接池负责分配,管理和释放数据库连接,它允许应用程序重复使用一个现在的数据库连接,而不是再重新建立一个. 这项技术能明显提高对数据库操作的性能
DataSource接口概述
- javax.sql.DataSource接口: 数据源(数据库连接池). Java官方提供的数据库连接池规范(接口)
- 如果想完成数据库连接池技术, 就必须实现DataSource接口
- 核心功能: 获取数据库连接对象: Connection getConnection()
自定义数据库连接池
- 定义一个类, 实现DataSource接口
- 定义一个容器, 用于保存多个Connection连接对象
- 定义静态代码块, 通过JDBC工具类获取10个连接保存到容器中
- 重写getConnection方法, 从容器中获取一个连接并返回
- 定义getSize方法, 用于获取窗口的大小并返回

package com.test001;

import com.lizicai.utils.JDBCUtils;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.logging.Logger;

public class MyDataSource implements DataSource {
    // 1. 准备窗口, 用于保存多个连接对象, 变成线程安全的
    private static List<Connection> pool = Collections.synchronizedList(new ArrayList<>());

    // 2. 定义代码块, 通过工具类获取10个连接对象
    static {
        for(int i=0;i<10;i++){
            Connection con = JDBCUtils.getConnection();
            pool.add(con);
        }
    }
    //3 重写getConnection() , 用于获取一个连接对象
    @Override
    public Connection getConnection() throws SQLException {
        if( pool.size()> 0){
            Connection con = pool.remove(0);
            return con;
        } else {
            throw new RuntimeException("连接数量已用尽");
        }
    }

    // 4. 定义getSize方法, 获取连接池窗口的大小
    public int getSize(){
        return pool.size();
    }
}

package com.test001;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MyDataSourceTest {
    public static void main(String[] args) throws SQLException {
        MyDataSource pool = new MyDataSource();

        System.out.println(pool.getSize());

        Connection con = pool.getConnection();

        String sql = "SELECT * FROM student";

        PreparedStatement pst = con.prepareStatement(sql);

        ResultSet rs = pst.executeQuery();

        while (rs.next()){
            System.out.println(rs.getInt("sid")+"\t"+rs.getString("NAME")
            +"\t"+rs.getInt("age")+"\t"+rs.getDate("birthday"));
        }

        rs.close();

        pst.close();

        con.close();

        System.out.println(pool.getSize());

    }
}

归还方式

归还数据库连接的方式
- 继承方式
- 装饰设计模式
- 我在适配器设计模式
- 动态代理方式

归还方式 - 继承方式

继承方式归还数据库连接的思想。
- 通过打印连接对象，发现 DriverManager 获取的连接实现类是 JDBC4Connection
- 那我们就可以自定义一个类，继承JDBC4Connection这个类，重写closeQ 方法，完成连接对象的归还
继承方式归还数据库连接的实现步骤。
- 定义一个类，继承JDBC4Connection。
- 定义 Connection 连接对象和连接池容器对象的成员变量。
- 通过有参构造方法完成对成员变量的赋值。
- 重写cose 方法，将连接对象添加到池中。
继承方式日还数据库连接存任的问题。
- 通过查看 JDBC 工具类获取连接的方法发现：我们星然白定义了一个子类，完成了归还连接的操作。但是
- DriverManager 获取的还是JDBC4Connection这个对象，并不是我们的子类对象，而我们又不能整体去修改驱动包中类的功能，所继承这种方式行不通！

归还连接 - 装饰设计模式

装饰设计模式日还数据库连接的思想。
- 我们可以自定义一个类，实现 Connection接口。这样就具备了和 JDBC4Connection相同的行为了
- 重写close()方法，完成连接的归还。其余的功能还调用 mysql驱动包实现类原有的方法即可
装饰设计模式归还数据库连接的实现步骤。
- 定义一个类，实现 Connection 接口
- 定义 Connection 连接对象和连接池容器对象的成员变量
- 通过有参构造方法完成对成员变量的赋值
- 重写close()方法，将连接对象添加到池中
- 剩余方法，只需要调用mysql驱动包的连接对象完成即可
- 在自定义连接池中，将获取的连接对象通过自定义连接对象进行包装
装饰设计模式归还数据库连接存在的问题。
- 实现 Connection接口后，有大量的方法需要在自定义类中进行重写

package com.test002;

import java.sql.*;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;

/**
 * 1. 定义一个类, 实现Connection接口
 * 2. 定义连接对象和连接池容器对象的成员变量
 * 3. 通过有参构造方法为成员变量赋值
 * 4. 重写close()方法, 完成归还连接
 * 5. 剩余方法, 还是调用原有的连接对象中的功能即可
 */

public class MyConnection2 implements Connection {
    private Connection con;
    private List<Connection> pool;

    public MyConnection2(Connection con, List<Connection> pool) {
        this.con = con;
        this.pool = pool;
    }

    @Override
    public void close() throws SQLException {
        pool.add(con);
    }
}

public class MyDataSource implements DataSource {
    //3 重写getConnection() , 用于获取一个连接对象
    @Override
    public Connection getConnection() throws SQLException {
        if( pool.size()> 0){
            Connection con = pool.remove(0);
            MyConnection2 myCon = new MyConnection2(con,pool);
            return myCon;
        } else {
            throw new RuntimeException("连接数量已用尽");
        }
    }
}

归还连接 - 适配器设计模式

适配器设计模式归还数据库连接的思想。
- 我们可以提供一个适配器类，实现 Connection 接口，将所有方法进行实现(除了close方法）
- 自定义连接类只需要继承这个适配器类，重写需要改进的close0 方法即可
适配器设计模式归还数据库连接的实现步骤。
- 定义一个适配器类, 实现 Connection 接口。
- 定义 Connection 连接对象的成员变量。
- 通过有参构造方法完成对成员变量的赋值。
- 重写所有方法(除了close), 调用mysq驱动包的连接对象完成即可。
- 定义一个连接类，继承适配器类。
- 定义 Connection 连接对象和连接池容器对象的成员变量，并通过有参构造进行赋值。
- 重写close()方法，完成归还连接。
- 在自定义连接池中，将获取的连接对象通过自定义连接对象进行包装。
适配器设计模式归还数据库连接存在的问题。
- 自定义连接类虽然很简洁, 但我在楼下器还是自己编写的, 也比较麻烦

public abstract class MyAdapter implements Connection {
    private Connection con;

    public MyAdapter(Connection con){
        this.con = con;
    }
    //省略其他实现的方法
}

package com.test002;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

public class MyConnection3 extends MyAdapter{
    private Connection con;
    private List<Connection> pool;

    public MyConnection3(Connection con, List<Connection> pool) {
        super(con);
        this.con = con;
        this.pool = pool;
    }

    @Override
    public void close() throws SQLException {
        pool.add(con);
    }
}

动态代理

动态代理: 在不改变目标对象方法的情况下对方法进行增强
组成
- 被代理对象: 真实的对象
- 代理对象: 内存的一个对象
要求
- 代理对象必须和被代理对象实现相同的接口
实现
- Proxy.newProxyInstance()

package com.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.eat("饭");
        stu.study();

        /**
         * 要求: 在不改Student类中任何代码前提下, 通过study方法输出一句话
         * 类加载器: 和被代理对象使用相同的类加载器
         * 接口类型Class数组: 和被代理对象使用相同接口
         * 代理规则: 完成代理增加的功能
         */
        StudentInterface proxyStu = (StudentInterface) Proxy.newProxyInstance(stu.getClass().getClassLoader(), new Class[]{StudentInterface.class}, new InvocationHandler() {
            /**
             * 执行student类中所有方法都会经过invoke方法
             * 对method方法进行判断
             *  如果是study, 则对其增强
             *  如果不是, 还调用学生对象原的功能即可
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if(method.getName().equals("study")){
                    System.out.println("学快点");
                    return null;
                } else {
                    return method.invoke(stu, args);
                }
            }
        });

        proxyStu.eat("米饭");
        proxyStu.study();
    }
}

归还连接 - 动态代理方式

动态代理方式归还数据库连接的思想。
- 我们可以通过 Proxy 来完成对 Connection 实现类对象的代理
- 代理过程中判断如果执行的是 close 方法，就将连接归还池中。如果是其他方法则调用连接对象原来的功能即可
动态代理方式归还数据库连接的实现步骤。
- 定义一个类，实现 DataSource接口
- 定义一个容器，用于保存多个Connection连接对象
- 定义静态代码块，通过JDBC工具类获取 10 个连接保存到容器中
- 重马getConnection 方法，从容器中获取一个连接
- 通过 Proxy 代理，如果是close 方法，就将连接归还池中。如果是其他方法则调用原有功能
- 定义 getsize 方法，用于获取容器的大小并返回
动态代理方式归还数据库连接存在的问题。
- 我们自己写的连接池技术不够完善，功能也不够强大

package com.test001;

import com.lizicai.utils.JDBCUtils;
import com.test002.MyConnection2;
import com.test002.MyConnection3;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.logging.Logger;

public class MyDataSource implements DataSource {
    // 1. 准备窗口, 用于保存多个连接对象, 更改List为线程安全的
    private static List<Connection> pool = Collections.synchronizedList(new ArrayList<>());

    // 2. 定义代码块, 通过工具类获取10个连接对象
    static {
        for(int i=0;i<10;i++){
            Connection con = JDBCUtils.getConnection();
            pool.add(con);
        }
    }
    // 动态代理归还Connection
    @Override
    public Connection getConnection() throws SQLException {
        if( pool.size()> 0){
            Connection con = pool.remove(0);
            Connection proxyCon =(Connection) Proxy.newProxyInstance(con.getClass().getClassLoader(), new Class[]{Connection.class}, new InvocationHandler() {
                /** 执行Connection 实现类连接对象所有的方法都会经过invoke
                 * 如果是close方法, 归还连接
                 * 如果不是, 直接执行连接对象原有的功能即可
                 *
                 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    if(method.getName().equals("close")){
                        pool.add(con);
                        return null;
                    } else {
                        return method.invoke(con, args);
                    }
                }
            });
            return proxyCon;
        } else {
            throw new RuntimeException("连接数量已用尽");
        }
    }

    // 4. 定义getSize方法, 获取连接池窗口的大小
    public int getSize(){
        return pool.size();
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {

    }

    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }
}

使用C3P0数据库连接池的使用步骤

导入Jar包, c3p0-0.9.5.5.jar和mchange-commons-java-0.2.19.jar
导入配置文件到src目录下
创建C3P0连接池对象
获取数据库连接进行使用

C3P0下载, 开头/c3p0-bin/c3p0-0.9.5.5/c3p0-0.9.5.5.bin.zip

配置文件示例下载Github地址

<?xml version="1.0" standalone="no" ?>

<!--
<!DOCTYPE c3p0-config [
   <!ENTITY extra SYSTEM "https://www.mchange.com/projects/c3p0/extra.xml">
]>-->

<c3p0-config>
  <default-config>
    <!-- <property name="automaticTestTable">con_test</property> -->
     <property name="checkoutTimeout">30000</property>
    <!-- <property name="idleConnectionTestPeriod">30</property> -->
     <property name="initialPoolSize">10</property>
    <!-- <property name="maxIdleTime">30</property> -->
    <!-- <property name="maxIdleTimeExcessConnections">10</property> -->
    <!-- <property name="maxConnectionAge">60</property> -->
    <!-- <property name="propertyCycle">1</property> -->
     <property name="maxPoolSize">5</property>
     <property name="minPoolSize">2</property>
    <!-- <property name="maxStatements">0</property> -->
    <!-- <property name="maxStatementsPerConnection">5</property> -->
    <!-- <property name="maxAdministrativeTaskTime">4</property> -->
    <!-- <property name="connectionCustomizerClassName">com.mchange.v2.c3p0.test.TestConnectionCustomizer</property> -->
    <!-- <property name="unreturnedConnectionTimeout">15</property> -->
    <!-- <property name="debugUnreturnedConnectionStackTraces">true</property> -->

    <!-- <property name="dataSourceName">poop</property> -->

     <property name="driverClass">org.mariadb.jdbc.Driver</property>
     <property name="jdbcUrl">jdbc:mariadb://192.168.0.100:3306/db14</property>
    <property name="user">root</property>
    <property name="password">rootPassword</property>

    <extensions>
      <!-- <property name="myXmlKey">myXmlVal</property> -->
      <!-- <property name="myKey">myOverriddenVal</property> -->
    </extensions>


    <user-overrides user="swaldman">
      <!--
      <property name="unreturnedConnectionTimeout">5</property>
      <property name="debugUnreturnedConnectionStackTraces">true</property>
      -->
      <!-- <property name="preferredTestQuery">select poop from doop</property> --><!-- intentionally broken -->
    </user-overrides>

<!--    &extra;-->

  </default-config>


<!--
  <named-config name="dumbTestConfig">
    <property name="maxStatements">200</property>
    <property name="jdbcUrl">jdbc:test</property>
    <property name="dataSourceName">scoop</property>
    <user-overrides user="poop">
      <property name="maxStatements">300</property>
    </user-overrides>
   </named-config>
-->

</c3p0-config>

使用默认的配置拿到连接, 可以正常使用了

 DataSource dataSource = new ComboPooledDataSource();
        Connection con = dataSource.getConnection();

package com.test003;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class C3P0Test2 {
    public static void main(String[] args) throws SQLException {
        DataSource dataSource = new ComboPooledDataSource();

        for(int i=1;i<=11;i++){
            Connection con = dataSource.getConnection();
            System.out.println(i+":"+con);
//            if( 5 == i){
//                con.close();
//            }
        }
    }
}

Druid连接池的使用

Druid 数据库连接池的使用步骡。
- 导入jar包, druid-1.2.8.jar
- 编写配置文件，放在src目录下。
- 通过 Properties 集合加载配置文件。
- 通过 Druid 连接池工厂类获取数据库连接池对象。
- 获取数据库连接进行使用。

Druid不会自动加载配置文件，需要我们手动加载，但是文样的名称可以自定义

driverClassName=org.mariadb.jdbc.Driver
url=jdbc:mariadb://192.168.0.100:3306/db14
username=root
password=rootPassword
initialSize=5
maxActive=10
maxWait=3000

package com.test004;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;

public class DruidTest1 {
    public static void main(String[] args) throws Exception {

//        获取配置文件的流对象
        InputStream is = DruidTest1.class.getClassLoader().getResourceAsStream("druid.properties");

//        1. 通过 Properties 集合, 加载配置文件
        Properties prop = new Properties();
        prop.load(is);

//        2. 通过Druid连接池工厂类获取数据库连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

//        3. 通过连接池对象获取数据库进行使用
        Connection con = dataSource.getConnection();

        String sql = "SELECT * FROM student";

        PreparedStatement pst = con.prepareStatement(sql);

        ResultSet rs = pst.executeQuery();

        while (rs.next()){
            System.out.println(rs.getInt("sid")+"\t"+rs.getString("NAME")
                    +"\t"+rs.getInt("age")+"\t"+rs.getDate("birthday"));
        }

        rs.close();

        pst.close();

        con.close();
    }
}

创建Druid 工具类

package com.lizicai.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * 数据库连接池的工具类
 */

public class DataSourceUtils {
    // 1. 私有构造方法
    private DataSourceUtils(){}

    // 2. 声明数据源变量
    private static DataSource dataSource;

    // 3. 提供静态代码块, 完成配置文件加载和获取数据库连接池对象
    static {
        try {
            InputStream is = DataSourceUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            Properties prop = new Properties();
            prop.load(is);
            dataSource =  DruidDataSourceFactory.createDataSource(prop);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 4. 提供一个获取数据库连接的方法
    public static Connection getConnection()  {
        Connection con = null;
        try {
            con = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return con;
    }


    // 5. 提供一个获取数据库连接池对象的方法
    public static DataSource getDataSource() throws Exception {
        return dataSource;
    }



    // 6. 释放资源的方法

    public static void close(Connection con, Statement stat, ResultSet rs){
        if(con != null){
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stat != null){
            try {
                stat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public static void close(Connection con, Statement stat){
        if(con != null){
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stat != null){
            try {
                stat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.test004;

import com.lizicai.utils.DataSourceUtils;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class DruidTest2 {
    public static void main(String[] args) throws SQLException {
        Connection con = DataSourceUtils.getConnection();

        String sql = "SELECT * FROM student";

        PreparedStatement pst = con.prepareStatement(sql);

        ResultSet rs = pst.executeQuery();

        while (rs.next()){
            System.out.println(rs.getInt("sid")+"\t"+rs.getString("NAME")
                    +"\t"+rs.getInt("age")+"\t"+rs.getDate("birthday"));
        }

       DataSourceUtils.close(con,pst,rs);
    }
}

JDBC数据库连接一 Li.060

Sun, 24 Oct 2021 19:03:55 +0800

JDBC 的概念

JDBC的概念
- JDBC(Java DataBase Connectivity Java数据库连接)是一种用于执行SQL语句的Java API, 可以为多种关系型数据库提供统一访问,它是由一组用Java语文编写的类和接口组成的
JDBC的本质
- 其实就是Java官方提供的一套规范(接口). 用于帮助开发人员快速实现不同关系型数据库的连接.
JDBC 的快速入门程序
- 导入Jar包
- 注册驱动
- 获取数据库连接
- 获取执行者对象
- 执行SQL语句并返回结果
- 处理结果
- 释放资源

JDBC包下载

package com.lizicai.jdbc;

import java.sql.*;

public class JDBCDemo1 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 导入Jar包, 已导入
        // 注册驱动, 也可以省略掉
        Class.forName("org.mariadb.jdbc.Driver");

        // 获取数据库连接
        Connection connection = DriverManager.getConnection
                ("jdbc:mariadb://192.168.0.100:3306/db10", "root", "rootPassword");

        // 获取执行者对象
        Statement statement = connection.createStatement();

        // 执行SQL语句并返回结果
        String sql = "SELECT * FROM city";
        ResultSet rs = statement.executeQuery(sql);

        // 处理结果
        while (rs.next()){
            System.out.println(rs.getInt("id")+","+rs.getString("NAME")+","+rs.getInt("VERSION"));
        }

        // 释放资源
        connection.close();
        statement.close();
    }
}

DriverManager

DriverManger驱动管理对象
- 注册驱动
  - 注册给定的驱动程序: static void registerDriver(Driver driver)
  - 写代码使用: Class.forName(“org.mariadb.jdbc.Driver”)
  - 在org.mariadb.jdbc.Driver类中存在静态代码块

static {
    try {
        DriverManager.registerDriver(new Driver(), new DeRegister());
    } catch (SQLException var1) {
        throw new RuntimeException("Could not register driver", var1);
    }
}

不需要通过DriverManager调用静态方法registerDriver(),因为只要Driver类被使用,则会执行其静态代码块完成注册驱动

MySQL5.0(MariaDB同样适用)之后可以省略注册驱动的步骤.在Jar包中,存在一个java.sql.Driver配置文件,文件中指定了com.mysql.jdbc.Driver

获取数据库连接
- 获取数据库连接对象static Connection getConnection(String url, String user, String password)
- 参数:
  - url数据库连接路径jdbc:mariadb://ip:端口/数据库,(mysql是jdbc:mysql://192.168.0.100:3306/db10)
  - user用户名
  - password

Connection

Connection 数据库连接对象
- 获取执行者对象
  - 获取普通执行都对象: Statement createStatement();
  - 获取预编译执行者对象: PreparedStatement prepareStatement(String sql)
- 管理事务
  - 开启事务: setAutoCommit(boolean autoCommit); 参数为false,则开启事务
  - 提交事务: commit();
  - 回滚事务: rollback();
- 释放资源
  - 立即将数据库连接对象释放: void close();

Statement

Statement执行SQL语句的对象
- 执行DML语句: int executeUpdate(String sql);
  - 返回值int: 返回影响的行数
  - 参数sql: 可能执行insert,update,delete语句
- 执行DQL语句: ResultSet executeQuery(String sql);
  - 返回值ResultSet: 封装查询的结果
  - 参数sql: 可能执行select语句
- 释放资源
  - 立即将执行者对象释放: void close();

ResultSet

ResultSet结果集对象
- 判断结果集中是否还有数据:boolean next();
  - 有数据返回true,并将索引向移动一行
  - 没有数据返回false
- 获取结果集中的数据: XXX getXxx(“列名”);
  - XXX代表数据类型(要获取某列数据,这一列的数据类型).
  - String getString(“name”) int getInt(“age”)
- 释放资源
  - 立即将结果集对象释放: void close();

JDBC案例需要

使用JDBC完成对student表的CRUD操作
数据准备

# 数据准备
CREATE DATABASE db14;
USE db14;

CREATE TABLE student(
    id INT PRIMARY KEY auto_increment,
    NAME VARCHAR(50),
    age INT,
    birthday DATE
);
INSERT INTO student VALUES (NULL,'张三',23,'1999-09-23');
INSERT INTO student VALUES (NULL,'李四',24,'1998-08-10');
INSERT INTO student VALUES (NULL,'五五',25,'1996-06-06');
INSERT INTO student VALUES (NULL,'赵六',26,'1994-10-20');

创建Student类

自定义类的功能是为了封装表中的系列数据,成员变量和列保持一致

所有基本数据类型需要使用对应包装类,以免表中NULL值无法赋值

public class Student {
    private Integer sid;
    private String name;
    private Integer age;
    private Date birthday;
}

练习

查询所有学生信息
根据id查询学生信息
新增学生信息
修改学生信息
删除学生信息

package com.lizicai.domain;

import java.util.Date;

public class Student {
    private Integer sid;
    private String name;
    private Integer age;
    private Date birthday;
    public Student(){}

    public Student(Integer id, String name, Integer age, Date birthday) {
        this.sid = id;
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public Integer getSid() {
        return sid;
    }

    public void setSid(Integer sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                '}';
    }
}

package com.lizicai.dao;

import com.lizicai.domain.Student;

import java.util.ArrayList;

public interface StudentDao {
    // 查询所有学生信息
    public abstract ArrayList<Student> findAll();

    // 条件查询, 根据id获取学生信息
    public abstract Student findById(Integer id);

    //新增学生信息
    public abstract int insert(Student stu);

    //修改学生信息
    public abstract int update(Student stu);

    //删除学生信息
    public abstract int delete(Integer id);
}

import com.lizicai.domain.Student;

import java.sql.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;

public class StudentDaoImpl implements StudentDao{
    /**
     * 查询所有学生
     * @return
     */
    @Override
    public ArrayList<Student> findAll() {
        ArrayList<Student> list = new ArrayList<>();
        Connection connection = null;
        Statement statement = null;
        ResultSet rs  = null;
        try {
            Class.forName("org.mariadb.jdbc.Driver");

            connection = DriverManager.getConnection
                    ("jdbc:mariadb://192.168.0.100:3306/db14", "root", "rootPassword");

            statement = connection.createStatement();

            String sql = "SELECT * FROM student";

            rs = statement.executeQuery(sql);

            while (rs.next()){
                Integer sid = rs.getInt("sid");
                String name = rs.getString("name");
                Integer age = rs.getInt("age");
                Date birthday = rs.getDate("birthday");
                list.add(new Student(sid,name,age,birthday));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(connection != null){
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(statement != null){
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(rs != null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return list;
    }
}

package com.lizicai.service;

import com.lizicai.domain.Student;

import java.util.ArrayList;

public interface StudentService {
    // 查询所有学生信息
    public abstract ArrayList<Student> findAll();

    // 条件查询, 根据id获取学生信息
    public abstract Student findById(Integer id);

    //新增学生信息
    public abstract int insert(Student stu);

    //修改学生信息
    public abstract int update(Student stu);

    //删除学生信息
    public abstract int delete(Integer id);
}

package com.lizicai.service;

import com.lizicai.dao.StudentDao;
import com.lizicai.dao.StudentDaoImpl;
import com.lizicai.domain.Student;

import java.util.ArrayList;

public class StudentServiceImpl implements StudentService{

    private StudentDao dao = new StudentDaoImpl();

    @Override
    public ArrayList<Student> findAll() {
        return dao.findAll();
    }

    @Override
    public Student findById(Integer id) {
        return dao.findById(id);
    }

    @Override
    public int insert(Student stu) {
        return dao.insert(stu);
    }

    @Override
    public int update(Student stu) {
        return dao.update(stu);
    }

    @Override
    public int delete(Integer id) {
        return dao.delete(id);
    }
}

package com.lizicai.controller;

import com.lizicai.domain.Student;
import com.lizicai.service.StudentService;
import com.lizicai.service.StudentServiceImpl;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Date;

public class StudentController {

    private StudentService service = new StudentServiceImpl();

    @Test
    public void findAll(){
        ArrayList<Student> list = service.findAll();
        for(Student stu:list){
            System.out.println(stu);
        }
    }
}

JDBC 工具类

编写配置文件
- 在src目录下创建config.properties配置文件

driverClass=org.mariadb.jdbc.Driver
url=jdbc:mariadb://192.168.0.100:3306/db14
username=root
password=rootPassword

编写JDBC 工具类

package com.lizicai.utils;

import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * JDBC 工具类
 */
public class JDBCUtils {


    // 1. 私有构造方法
    private JDBCUtils(){}

    //    2. 声明所需要的配置变量
    private static String driverClass;
    private static String url;
    private static String username;
    private static String password;
    private static Connection con;

    //    3. 提供静态代码块. 读取配置文件信息为变量赋值,注册驱动
    static {

        try {
            // 读取配置文件的信息为变量赋值
            InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("config.properties");
            Properties properties = new Properties();
            properties.load(is);

            driverClass = properties.getProperty("driverClass");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");

            // 注册驱动
            Class.forName(driverClass);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

//    4. 提供获取数据库连接方法
    public static Connection getConnection(){
        try {
            con = DriverManager.getConnection(url,username,password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return con;
    }
//    5. 提供释放资源的方法

    public static void close(Connection con, Statement stat, ResultSet rs){
        if(con != null){
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stat != null){
            try {
                stat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public static void close(Connection con, Statement stat){
        if(con != null){
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stat != null){
            try {
                stat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.lizicai.dao;

import com.lizicai.domain.Student;
import com.lizicai.utils.JDBCUtils;

import java.sql.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;

public class StudentDaoImpl2 implements StudentDao{
    /**
     * 查询所有学生
     * @return
     */
    @Override
    public ArrayList<Student> findAll() {
        ArrayList<Student> list = new ArrayList<>();
        Connection con = null;
        Statement stat = null;
        ResultSet rs  = null;
        try {

            con = JDBCUtils.getConnection();

            stat = con.createStatement();

            String sql = "SELECT * FROM student";

            rs = stat.executeQuery(sql);

            while (rs.next()){
                Integer sid = rs.getInt("sid");
                String name = rs.getString("name");
                Integer age = rs.getInt("age");
                Date birthday = rs.getDate("birthday");
                list.add(new Student(sid,name,age,birthday));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(con,stat,rs);
        }

        return list;
    }
}

Student表的CRUD操作整合页面

# 数据准备
use db14;
CREATE TABLE USER(
    uid VARCHAR(50) PRIMARY KEY ,
    ucode VARCHAR(50),
    loginname VARCHAR(100),
    PASSWORD VARCHAR(100),
    username VARCHAR(100),
    gender VARCHAR(10),
    birthday DATE,
    dutydate DATE
);
INSERT INTO USER VALUES
('11111111','zhangsan001','zhangsan','1234','张三','男','2008-10-28','2018-10-28');
select * from USER;

SQL 注入攻击

什么是SQL注入攻击
- 就是利用SQL语句的漏洞来对系统进行攻击
SQL注入解决
- PreparedStatement预编译执行者对象
  - 在执行SQL语句前, 将SQL语句

PreparedStatement stat = null;
String sql = "SELECT * FROM USER WHERE loginname=? AND PASSWORD=?";
stat = con.prepareStatement(sql);
stat.setString(1,user.getLoginname());
stat.setString(2,user.getPASSWORD());
rs = stat.executeQuery();

JDBC 事务

JDBC 管理事务
- 管理事务的功能类:Connection
  - 开启事务: setAutoCommit(boolean autoCommit); 参数为false, 则开启事务
  - 提交事务: commit();
  - 关闭事务: close();

事务的控制放在service层做, dao层只存放, 下为dao层

@Override
public void save(Connection con, User user) {
    PreparedStatement stat = null;
    ResultSet rs = null;

    String sql = "insert into USER values (?,?,?,?,?,?,?,?)";
    java.sql.Date birthday = new java.sql.Date(user.getBirthday().getTime());
    java.sql.Date dutyday = new java.sql.Date(user.getDutyday().getTime());
    try {
        stat = con.prepareStatement(sql);
        stat.setString(1, user.getUid());
        stat.setString(2, user.getUcode());
        stat.setString(3, user.getLoginname());
        stat.setString(4, user.getPASSWORD());
        stat.setString(5, user.getUsername());
        stat.setString(6, user.getGender());
        stat.setDate(7, birthday);
        stat.setDate(8, dutyday);
        stat.executeUpdate();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

int a = 1/0;模拟异常,去掉则可以正常存进来数据,service层

@Override
public void batchAdd(List<User> userList) {
    Connection con = JDBCUtils.getConnection();
    try{
        //开户事务
        con.setAutoCommit(false);
        for(User user : userList){
            //创建id, 并把uuid
            String uid = UUID.randomUUID().toString().replace("-","").toUpperCase(Locale.ROOT);
            user.setUid(uid);
            user.setUcode(uid);
            int a = 1/0;
            userDao.save(con, user);
        }
        // 提交事务
        con.commit();
    } catch (Exception e){
        // 回滚
        try {
            con.rollback();
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        e.printStackTrace();
    } finally {
        JDBCUtils.close(con,null);
    }
}

@Test
public void batchAddTest()  {
    ArrayList<User> userList = new ArrayList<>();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    try {
        userList.add(new User(null,null,"lisi",
                    "123456","李四","男",sdf.parse("1992-02-04"),sdf.parse("2000-10-09")));
        userList.add(new User(null,null,"wangwu",
                    "123456","王五","男",sdf.parse("1992-02-05"),sdf.parse("2000-10-09")));
        userList.add(new User(null,null,"zhaoliu",
                    "123456","赵六","男",sdf.parse("1992-02-06"),sdf.parse("2000-10-09")));
        userService.batchAdd(userList);
    } catch (ParseException e) {
        e.printStackTrace();
    }
}

MySQL数据库二 Li.059

Wed, 20 Oct 2021 18:00:28 +0800

视图

视图介绍
- 视图：是一种虛拟存在的数据表，这个虚拟表并不在数据库中实际存在。
- 作用：将一些较为复系的查询语句的结果，封装到-个虚拟表中，后期再有相同需求时，直接道询该虚拟表即可

# 准备数据
create database mydb5;
use mydb5;
create table country(
    id int primary key auto_increment,
    NAME varchar(30)
);
insert into country values (null,'中国'),(null,'美国'),(null,'俄罗斯');
create table city(
    id int primary key auto_increment,
    NAME varchar(30),
    cid int,
    constraint cc_fk1 foreign key (cid) references country(id)
);
insert into city values (null,'北京',1),(null,'上海',1),(null,'纽约',2),(null,"莫斯科",3);

视图的创建和查询

创建视图语法: create view 视图名称 [(列名列表)] as 查询语句;
查询视图语法: select * from 视图名称;

## 创建视图
create view city_country (city_id,city_name,country_name) as
select c1.id,c1.NAME,c2.NAME
from city c1,
     country c2
where c1.cid = c2.id;
select * from city_country;

修改视图数据语法: update 视图名称 set 列名=值 where 条件; 修改视图的数据,原表的数据也会修改

## 修改视图数据
update city_country set city_name ='深圳' where city_name='北京';

修改视图结构语法: alter view 视图名称 (列名列表) as 查询语句;
删除视图语法: drop view [if exists] 视图名称;

## 修改视图结构
alter view city_country (city_id,city_name,NAME) as
   select c1.id,c1.NAME,c2.NAME
from city c1,
     country c2
where c1.cid = c2.id;
## 删除视图
drop view if exists city_country;

数据库备份和恢复

备份-命令行方式
- 登录到MySQL服务器, mysqldump -uroot -p 数据库名称>文件保存路径(sql结尾文件)
恢复
- 登录MySQL数据库
- 删除已备份的数据库
- 重新创建名称相同的数据库
- 使用该数据库
- 导入文件执行: source 备份文件全路径

# 备份-命令行操作
mysqldump -uroot -p backupdatabase > /root/backupdatabase.sql

# 恢复-命令行操作
mysqldump -uroot -p

show databases;
drop backupdatabase;
create database backupdatabase;
use backupdatabase;
source /root/backupdatabase.sql;

备份-使用Datagrip
- Export with ‘mysqldump’
恢复
- 使用Datagrip
- 删除已备份的数据库
- 重新创建名称相同的数据库
- 在数据库右键 Run SQL Script, 选择导出的文件.sql

存储过程和函数介绍

存储过程和函数是事先经过编译并存储在数据库的一段SQL说一句的集合
存储过程和函数的好处
- 提高代码的复用性
- 减少数据在数据库和应用服务器之间的传输, 提高效率
- 减少代码层面的业务处理
存储过程和函数的区别
- 存储函数必须有返回值
- 存储过程可以没有返回值

存储过程的创建和调用

创建存储过程

# 修改结束分隔符
delimiter $

# 创建存储过程
create procedure 存储过程名称(参数列表)
BEGIN
    SQL语句列表;
END$

# 修改结束分隔符
DELIMITER ;

调用存储过程
- CALL 存储过程名称(实际参数);

## 存储过程数据准备
create database mydb6;
use mydb6;
create table student(
    id int primary key auto_increment,
    NAME varchar(20),
    age int,
    gender varchar(5),
    score  int
);
insert into student values
(null,'张三',23,'男',95),
(null,'李四',24,'男',98),
(null,'王五',25,'女',100),
(null,'赵六',26,'女',90);

# 按照性别进行分级, 查询每组学生的总成绩. 按钮总成绩的升序排序
select gender,SUM(score) as getSum from student group by gender order by getSum asc;

delimiter $
create procedure stu_group()
BEGIN
    select gender,SUM(score) as getSum from student group by gender order by getSum asc;
END $
delimiter ;

call stu_group();

存储过程的查看和删除

查看数据库中所有的存储过程
- select * from mysql.proc where db=‘数据库名称’;
删除存储过程
- drop procedure [if exists] 存储过程名称;

# 查看存储过程
select * from mysql.proc where db='mydb6';
# 删除存储过程
drop procedure if exists stu_group;

存储过程语法 - 变量

定义变量: declare 变量名数据类型 [default 默认值];
变量赋值方式一: set 变量名=变量值;
变量赋值二: select 列名 into 变量名 from 表名 [where 条件];

# 按照性别进行分级, 查询每组学生的总成绩. 按钮总成绩的升序排序
select gender,SUM(score) as getSum from student group by gender order by getSum asc;

delimiter $
create procedure stu_group()
BEGIN
    select gender,SUM(score) as getSum from student group by gender order by getSum asc;
END $
delimiter ;

call stu_group();

# 查看存储过程
select * from mysql.proc where db='mydb6';
# 删除存储过程
drop procedure if exists stu_group;

delimiter $
create procedure pro_test1()
begin
    declare  num int default 10;
    select num;
end $
delimiter ;
call pro_test1();

delimiter $
create procedure pro_test2()
begin
    declare NAME varchar(10);
    set NAME='存储过程';
    select NAME;
end $
delimiter ;

call pro_test2();

delimiter $
create procedure pro_test3()
begin
    declare woman_sum_score,man_sum_score int;
    select sum(score) into woman_sum_score from student where gender='女';
    select sum(score) into man_sum_score from student where gender='男';
    select woman_sum_score,man_sum_score;
end $
delimiter ;

call pro_test3();

存储过程语法 - if语句

if语句

if 判断条件1 then 执行的SQL语句1;
    [elseif 判断条件2 then 执行的SQL语句2]
    ...
    [else 执行的SQL语句n]
end if;

# 定义变量int 存储班级总成绩
# 定义vachar变量量, 用于存储分数描述
# 根据总成绩判断: 380分以上 学习优秀, 320~380 学习不错, 320以下 学习一般
delimiter $
create procedure pro_test4()
begin
    declare all_sum_score int;
    declare info varchar(30);
    select sum(score) into all_sum_score from student;
    if all_sum_score>380 then set info='学习优秀';
    elseif (all_sum_score<=380 && all_sum_score >=320) then set info='学习不错';
    else set info='学习一般';
    end if;
    select all_sum_score,info;
end $
delimiter ;

call pro_test4();

存储过程语法 - 参数传递

存储过程的参数和返回值

delimiter $
create procedure 存储过程名称 ([IN|OUT|INOUT] 参数名 数据类型)
begin
    SQL语句;
end$
delimiter ;

参数
- IN: 代表输入参数,需要由调用者传递实际数据(默认)
- OUT: 代表输入参数, 该参数可以作为返回值
- INOUT: 代表既可以作为输入参数, 也可以作为输入参数

delimiter $
create procedure pro_test5(IN all_sum_score int,OUT info varchar(30))
begin
    if all_sum_score>380 then set info='学习优秀';
    elseif (all_sum_score<=380 && all_sum_score >=320) then set info='学习不错';
    else set info='学习一般';
    end if;
end $
delimiter ;

call pro_test5(320,@info);
call pro_test5((select sum(score) from student),@info);
select @info;

存储过程语法 - while循环

while循环语法

初始化语句;
while 条件判断语句 do
    循环体语句;
    条件控制语句;
end while;

delimiter $
create procedure pro_test6()
begin
    declare result int default 0;
    declare i int default 1 ;
    while i < 101 do
        if i%2=0 then
       set result = result + i;
       end if;
        set i = i + 1;
    end while;
    select result;
end $
delimiter ;
call pro_test6;

存储函数

存储函数和存储过程是非常相似的, 区别在于存储函数必须有返回值
创建存储函数

delimiter $
create function 函数名称(参数列表)
returns 返回值类型
begin
    SQL语句列表;
    RETURN结果;
end$
delimiter ;

调用存储函数
- select 函数名称(实际参数);
删除存储函数
- drop function 函数名称;

delimiter $
create function fun_test1()
RETURNS int
begin
    declare num int;
    select count(*) into num from student where score>95;
    return num;
end $
delimiter ;

select fun_test1();

drop function fun_test1;

MySQL 触发器

触发器是与表有关的数据库对象, 可以在insert,update,delete之前或之后触发并执行触发器中定义的SQL语句.
这种特性可以协助应用系统在数据库端确保数据的完整性,日志记录,数据校验等操作.
使用别名NEW和OLD来引用触发器中发生变化的内容记录
触发器分类

触发器类型     OLD                           NEW
INSERT型触发器 无(插入前无数据)              NEW表示将要或者已经新增的数据
UPDATE型触发器 OLD表示修改之前的数据         NEW表示将要或已经修改后的数据
DELETE型触发器 OLD表示将要或者已经删除的数据 无(删除删除后状态无数据)

触发器的操作

创建触发器

delimiter $
create trigger 触发器名称
before|after insert|update|delete
on 表名
fro each row
begin
    触发器要执行的功能;
end $
delimiter ;

# 数据准备
create database mydb7;
use mydb7;

create table account(
    id int primary key auto_increment,
    NAME varchar(20),
    money double
);
insert into account values (null,'张三',1000),(null,'李四',1000);
create table account_log(
    id int primary key auto_increment,
    operation varchar(20),
    operation_time datetime,
    operation_id int,
    operation_params varchar(200)
);

# 插入触发器
delimiter $
create trigger account_insert
    after INSERT
    on account
    for each row
    begin
        insert into account_log values (null,'INSERT',now(),new.id,
                                        CONCAT('插入后{id=',new.id,',name=',new.NAME,',money=',new.money,'}'));
    end $
delimiter ;
insert into account values (null,'王五',2000);
select * from account;
select * from account_log;

# 更新触发器
delimiter $
create trigger account_update
    after UPDATE
    on account
    for each row
    begin
        insert into account_log values (null,'UPDATE',now(),new.id,
                                        CONCAT('更新前{id=',old.id,',name=',old.NAME,',money=',old.money,'}',
                                            '更新后{id=',new.id,',name=',new.NAME,',money=',new.money,'}'));
    end $
delimiter ;
select * from account;
update account set money=2000 where id=2;
select * from account_log;

# 删除触发器
delimiter $
create trigger account_delete
    after DELETE
    on account
    for each row
    begin
        insert into account_log values (null,'DELETE',now(),old.id,
                                        CONCAT('删除前{id=',old.id,',name=',old.NAME,',money=',old.money,'}'));
    end $
delimiter ;
select * from account;
delete from account where id=3;
select * from account_log;

触发器的操作

查看触发器: show triggers;
删除触发器: drop trigger 触发器名称;

# 查看触发器
show triggers ;
# 删除触发器
drop trigger account_delete;

MySQL 事务

事务: 一条或多条SQL语句组成一个执行单元, 其特点是这个单元要么同时成功要么同时失败
单元中的每条SQL语句都相互依赖, 形成一个整体
如果某条SQL语句执行失败或者出现错误, 那么整个单元就会撤回到事务最初的状态.
如果单元中所有的SQL语句都执行成功, 则事务就顺利执行.

事务的操作

开启事务: start transaction;
回滚事务: rollback;
提交事务: commit;

# 准备数据
create database db8;
use db8;
create table account(
    id int primary key auto_increment,
    NAME varchar(20),
    money double
);
insert into account values (null,'张三',1000),(null,'李四',1000);
select * from account;


# 开启事务
start transaction ;
update account set money=money-500 where NAME='张三';
update account set money=money+500 where NAME='李四';
# 回滚事务
rollback ;
# 提交事务
commit ;

事务的提交方式

事务提交方式的分类
- 自动提交(MySQL默认)
- 手动提交
查看事务提交方式
- select @@autocommit;
修改事务提交方式
- set @@autocommit=数字;

# 查询事务的提交方式
select @@autocommit;
# 修改事务的提交方式
# 默认是1, 不可修改
set @@autocommit=0;

事务的四大特征

原子性(Atomicity)
- 原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚。
- 因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。
一致性(Consistency)
- 一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态。
- 也就是说一个事务执行之前和执行之后都必须处于一致性状态。
隔离性(isolcation)
- 隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务。
- 不能被其他事务的操作所千扰，多个并发事务之问要相互隔离。卜
持久性(durability)
- 持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的。
- 即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

事务的隔离级别

事务的隔离级别
- 多个客户端操作时，各个客户端的事务之间应该是隔离的，相互独立的，不受影响的。
- 而如果多个事务操作同一批数据时，就会产生不同的问题，我们需要设置不同的隔离级别来解决这些问题。

隔离级别分类	隔离级别	会引发的问题
read uncommitted	读末提交	脏读、不可重复读、幻读
read committed	读已提交	不可重复读、幻读
repeatable read	可重复读	幻读
serializable	串行化	无

引发的问题

问题	现象
脏读	在一个事务处理过程中读取到了另一个未提交事务中的数据,导致2次查询结果不一致
不可重复读	在一个事务处理过程中读取到了另一个事务中修改并已提交的数据,导致2次查询结果不一对我
幻读	查询某数据不存在,准备插入此记录,但执行插入时发现此记录已存在,无法插入.或查询数据不存在执行删除操作,却发现删除成功

事务的隔离级别

查询数据库隔离级别
- select @@tx_isolation;
修改数据库隔离级别(需要重新连接)
- set global transaction isolation level 级别字符串;

# 查询事务隔离级别
select @@tx_isolation;
# 修改事务隔离级别(修改后需要重新连接)
set global transaction isolation level read committed ;

隔离级别问题演示
- 脏读问题演示

set global transaction isolation level read uncommitted ;
start transaction ;
update account set money=money-500 where NAME='张三';
update account set money=money+500 where NAME='李四';
# 提交事务
select * from account;
rollback ;

# 同时开启, 在上一用户transaction执行期间查询, 把transcation未commit的数据读取出来了.
start transaction ;
select * from account;
COMMIT;

解决脏读设置为: set global transaction isolation level read committed ;

不可重复读问题演示和解决
- 不可重复读: 一个事务中读取到其他事务已提交的数据

set global transaction isolation level read committed;
start transaction ;
update account set money=money-500 where NAME='张三';
update account set money=money+500 where NAME='李四';
# 提交事务
select * from account;
COMMIT;

# 同时开启, 在上一用户transaction执行期间查询, 把transcation未commit的数据读取出来了.
# 第2次读, 前面commit;完成后读, 数据变化了.
start transaction ;
select * from account;
COMMIT;

解决不可重复读解决: set global transaction isolation level repeatable read ; 在事务2中读多次,还是事务1提交前的数据.

幻读的问题演示
- 查询某记录是否存在, 不存在
- 准备插入此记录, 但执行插入时发现此记录
- 或某记录不存在执行删除, 却发现删除成功

start transaction ;
insert into account values (3,'王五',2000);
select * from account;
commit ;

# 同时事务, 插入操作, 事务2执行失败
start transaction ;

select * from account;
insert into account values (3,'王五',2000);
COMMIT;

解决幻读: set global transaction isolation level serializable;

事务的隔离级别

序号	隔离级别	名称	脏读	不可重复读	幻读	数据库默认隔离级别
1	read uncommitted	读未提交	是	是	是
2	read committed	读已提交	否	是	是	Oracle
3	repeatable read	可重复读	否	否	是	MySQL
4	serializable	串行化	否	否	否

隔离级别从小到大安全性越来越高, 但是效率越来越低, 不建议修改数据库默认的隔离级别

MySQL 体系结构-存储引擎

客户端连接
- 支持接口：支持的客户端连接，例如 C、Java、PHP等语言来连接MySQL数据库。
第一层：网络连接层
- 连接池：管理、缓冲用户的连接，线程处理等需要缓存的需求。
第二层：核心服务层
- 管理服务和工具：系统的管理和控制工具，例如备份恢复、复制、集群等。
- SQL 接口：接受 SQL 命令，并且返回查询结果。
- 查询解析器：验证和解析 SQL 命令，例如过滤条件、语法结构等。
- 查询优化器：在执行查询之前，使用默认的一套优化机制进行优化sql语句。
- 缓存：如果缓存当中有想查询的数据，则直接将缓存中的数据返回。没有的话再重新查询。
第三层：存储擎层
- 插件式存储引(擎：管理和操作数据的一种机制，包括(存储数据、如何更新、查询数据等
第四层：系统文件层
- 文件系统：配置文件、数据文件、日志文件、错误文件、二进制文件等等的保存。

存储引擎介绍

MysQL 数据库使用不同的机制存取表文件，包括存储方式、索引技巧、锁定水平等不同的功能。这些不同的技术以及配套的功能称为存储引擎。
Oracle、SalServer 等数据库只有一种存储引擎。而MySQL针对不同的需求,配置不同的存储引1擎,就会让数据库采取不同处理数据的方式和扩展功能。
MysQL 支持的存储引l擎有很多，常用的有三种：InnoDB、 MyISAM、MEMORY。
特性对比
- MyISAM 存储引擎：访问快，不支持事务和外键操作。
- InnoDB 存储引擎：支持事务和外键操作，支持并发控制，占用磁盘空间大。(MySQL5.5版本后默认
- MEMORY 存储引!擎：内存存储，速度快，不安全。适合小量快速访问的数据。

特性	MyISAM	InnoDB	MEMORY
存储限制	有(平台对文件系统大小的限制)	64TB	有(平台的内存限制)
事务安全	不支持	支持	不支持
锁机制	表锁	表锁/行锁	表锁
B+Tree索引	支持	支持	支持
哈希索引	不支持	不支持	支持
全文索引	支持	支持	不支持
集群索引	不支持	支持	不支持
数据索引	不支持	支持	支持
数据缓存	不支持	支持	N/A
索引缓存	支持	支持	N/A
数据可压缩	支持	不支持	不支持
空间使用	低	高	N/A
内存使用	低	高	中等
批量插入速度	高	低	高
外键	不支持	支持	不支持

存储引擎的操作

查询数据库支持的存储引擎: show engines;
查询某个数据库中的所有数据表的存储引擎: show table status from 数据库名称;
查询某个数据库中某个数据表的存储引擎: show table status from 数据库名称 where name=‘数据表名称’;
创建数据表,指定存储引擎

create table 表名(
    列名, 数据类型,
    ...
)ENGINE = 引擎名称;

修改数据表的存储引擎: alter table 表名 ENGINE=引擎名称;

# 查询数据库支持的存储引擎:
show engines;
# 查询某个数据库中的所有数据表的存储引擎:
show table status from mydb4;
# 查询某个数据库中某个数据表的存储引擎:
show table status from mydb4 where name='USER';
# 创建数据表,指定存储引擎
use db8;
create table test_engine(
    id int
)engine = MyISAM;
show table status from db8;
# 修改数据表的存储引擎
alter table test_engine engine = INNODB;

存储引擎的选择

MyISAM
- 特点: 不支持事务和外键. 读取速度快, 节约资源
- 使用场景: 以查询操作为主, 只有很少的更新和删除操作, 并且对事务的完整性,并发性要求不是很高
InnoDB
- 特点: MySQL的默认存储引擎
- 使用场景: 对事务的完整性有比较高的要求, 在并发条件下要求数据的一致性, 读写频繁的操作
MEMORY
- 特点: 将所有数据保存在内存中, 在需要快速定位记录和其他类似数据环境下, 可以提供更快的访问.
- 使用场景: 通常用于更新不太频繁的小表, 用来快速得到访问的结果

如果不确定,则使用数据库默认的存储引擎

MySQL 的索引

索引介绍

MySQL索引: 是帮助MySQL高效获取数据的一种数据结构. 所以, 索引的本质就是数据结构
在表数据之外, 数据库系统还维护着满足特写查找算法的数据结构, 这些数据结构以某种方式指向数据, 这样就可以在这些数据结构上实现高级查找算法, 这种数据结构就是索引

索引的操作

按照功能分类
- 普通索引：最基本的索引，没有任何限制。
- 唯一索引：索引列的值必须唯—，但允许有空值。如果是组合素引，则列值组合必须唯一
- 主键索引：一种特殊的唯一索引，不允许有空值。在建表时有主键列同时创建主键奈引。
- 联合素引：顾名思义，就是将单列索引进行组合。
- 外键索引：只有InnoDB 引李支持外键索引，用来保证数据的一致性、完整性和实现级联操作。
- 全文素引：快速匹配全部文档的方式。InnoDB引擎 5.6版本后才支持全文素引。MEMORY 引擎不支持。
按照结构分类
- BTree 索引：MySQL使用最频繁的一个素引（数据结构，是lInnoDB 和 MyISAM 存储引草默认的索号类型，底层基于 B+Tree 数据结构。
- Hash 奈引：MySQL 中 Memory 存储引擎默认支持的奈引类型。
创建索引

# 无索引名称,则是默认BTree
create [unique|fulltext] index 索引名称 [using 索引类型]
on 表名(列名...);

查看索引: show index from 表名;

# 数据准备
create database db9;
use db9;
create table student(
    id int primary key auto_increment,
    NAME varchar(20),
    age int,
    score int
);
insert into student values
(null,'张三',23,98),
(null,'李四',24,95),
(null,'王五',25,96),
(null,'赵六',26,94),
(null,'周七',27,99);
select * from student;

# 为student表的name列创建一个普通索引
create index idx_name on student(NAME);
# 为student表的age列创建一个唯一索引
create unique index idx_age on student(age);
# 查询student索引 (主键列自带主键索引)
show index from student;
# 查询mydb4数据库的product表(外键列自带外键索引)
show index from mydb4.product;

添加索引
添加索引
- 普通索引：ALTER TABLE 表名 ADD INDEX索引名称（列名);
- 组合索引：ALTER TABLE 表名 ADD INDEX索引名称(列名1,列名2….);
- 主键索引：ALTER TABLE 表名 ADD PRIMARY KEY(主键列名);
- 外键索引：ALTER TABLE 表名 ADD CONSTRAINT 外键名 FOREIGN KEY （本表外键列名)REFERENCES 主表名(主键列名);
- 唯一索引：ALTER TABLE 表名 ADD UNIQUE 索引名称(列名);
- 全文索引：ALTER TABLE 表名 ADD FULLTEXT 索引名称(列名);
删除索引
- drop index 索引名 on 表名;

# 添加index
alter table student add unique idx_score(score);
# 删除index
alter table student drop index idx_name1;
drop index idx_name1 on student;

索引的原理

BTree数据结构
- 每个节点中不仅包含key值,还有数据. 会增加查询数据时磁盘的IO次数
B+Tree数据红塔区
- 非叶子节点只存储key值
- 所有数据存储在叶子节点
- 所有叶子节点之间都有连接指针
B+Tree好处
- 提高查询速度
- 减少磁盘的IO次数
- 树形结构较小

索引的设计原则

创建索引遵循的原则
- 对查询频次较高, 且数据量比较大的表建立索引
- 使用唯一索引,区分度越高,使用索引的效率越高
- 索引字段的选择,最佳做眉毛列应当从where子句的条件中提取
- 索引虽然可以有效的提升查询数据的效率, 也并不是多多益善
最左匹配原则(适合组合索引)
例如: 为user中的name,address,phone列添加组合索引
- alter table user add index idx_three(name,address,phone);
此时,组合索引idx_three实际建立了(name),(name,address),(name,address,phone)三个索引
下面的三个SQL语句都可以命中索引

select * from user where address='北京' and phone='12345' and name='张三';
select * from user where name='张三' and address='北京';
select * from user where name='张三';

这三条SQL语句在检索时分别会使用以下索引进行数据匹配
- (name,address,phone)
- (name,address)
- (name)
索引字段出现的顺序可以是任意的, MySQL优化器会帮我们自动的调整where条件中的顺序
如果组合索引中最左边的列不在查询条件中, 则不会命中索引
- select * from user where address=‘北京’;

MySQL 锁机制

锁机制: 数据库为了保证数据的一致性, 在共享的资源被管他访问时变得案例所设计的一种规则
锁机制类似多线程的同步, 作用可以保证数据的一致性和案例性
按操作分类
- 共享锁: 也叫读锁. 针对同一份数据, 多个事务读取操作可以同时加锁而互相不影响, 但是不能修改数据
- 揍他锁: 也叫写锁. 当前的操作没有完成前, 会阻断其他操作的读取和写入.
按粒度分类
- 表级锁: 会锁定整个表. 开销小, 加锁快. 锁定力度大, 发生锁冲突概率高, 并发低. 不会出现死锁情况.
- 行级锁: 会锁定当前行. 开销大, 加锁慢. 锁定粒度小, 发生锁冲突概率低, 并发度高. 会出现死锁情况.
按使用方式分类
- 悲观锁: 第次查询数据时都认为别人会修改, 很悲观, 所有查询时加锁
- 乐观锁: 第次查询数据时都认为别人不会修改, 很乐观, 但是更新时会判断一下在此期间别人有没有去更新这个数据.
不同存储引擎支持的锁

存储引擎	表锁	行锁
InnoDB
MyISAM
MEMORY

InnoDB 共享锁

共享锁特点
- 数据可以被多个事务查询, 但是不能修改
创建共享锁格式
- select 语句 lock in share mode;

InnoDB带索引的列是行锁

start transaction ;
select * from student where id = 1 lock in share mode ;
commit ;

# 同时开启事务, 更新这行数据
start transaction ;
update student set NAME='张三三' where id =1;
update student set NAME='李四四' where id =2;
commit;

InnoDB非索引列,加的就表锁

start transaction ;
select * from student where score=98 lock in share mode ;
commit ;

# 同时开启事务, 更新这行数据
start transaction ;
update student set NAME='王五五' where id =3;
commit;

InnoDB 排他锁

揍他锁特点
- 加锁的数据, 不能被其他事务加锁查询或修改
- 普通查询则可以
创建排他锁格式
- select语句 for update;

start transaction ;
select * from student where id=1 for update;
commit ;

# 同时开启事务
start transaction;
# 普通查询没有问题
select * from student where id=1 ;
# 查询id为1的数据, 并加入共享锁, 不能
select * from student where id=1 lock in share mode ;
# 查询id为1的数据, 并加入排他锁, 不能
select * from student where id=1 for update;
# 修改数据也是, 不能
update student set NAME='张三' where id=1;
commit;

MyISAM 读锁

读锁特点
- 所有的连接只能查询数据,不能修改
读锁语法格式
- 加锁: lock table 表名 read;
- 解锁: unlocak tables;

# 准备数据
create table product(
    id int primary key auto_increment,
    NAME varchar(20),
    price int
) engine = MYISAM;
insert into product values
(null,'华为手机',4999),
(null,'苹果',8999),
(null,'中兴',1999);
select * from product;
show table status from db10 where name='product';

# 窗口1, 增加读锁
lock tables product read;
select * from product;
unlock tables ;


# 窗口2, 可查询
select * from product;
# 不可修改, 只有窗口1解锁后才能修改
update product set price=5999 where id=1;

MyISAM 写锁

写锁特点
- 其他连接不能查询和修改数据
写锁语法格式
- 加锁: lock table 表名 write;
- 解锁: unlocak tables;

# 窗口1, 增加写锁
lock tables product write ;
# 可在窗口1查询
select * from product;
# 可在窗口1更新
update product set price=5999 where id=1;
unlock tables ;

# 窗口2, 不可查询, 只有窗口1解锁才能查询
select * from product;
# 不可修改, 只有窗口1解锁后才能修改
update product set price=4999 where id=1;

悲观锁和乐观锁

悲观锁
- 就是很悲观, 它对于数据被外界修改的操作持保守感谢感谢, 认为数据随时会修改
- 整个数据处理中需要将数据加锁. 悲观锁一般都是依靠关系型数据库提供的锁机制
- 之前所学的锁机制都是悲观锁
乐观锁
- 就是很乐观, 第次自己操作数据的时候认为没有人会来修改它, 所有不去加锁
- 但是在更新的时候会去判断在此期间数据有没有被修改
- 需要用户自己去实现, 不会发生并发抢占资源, 只有在提交操作的时候检查是否违反数据完整性.

乐观锁的解决方式

方式一
- 给数据表中添加一个version 列，每次更新后都将这个列的值加1.
- 读取数据时，将版本号读取出来，在执行更新的时候，比较版本号。
- 如果相同则执行更新，如果不相同，说明此条数据已经发生了变化。
- 用户自行根据这个通知来决定怎么处理，比如重新开始一遍，或者放弃本次更新。
方式二
- 和版本号方式基本一样，给数据表中添加一个列，名称无所谓，数据类型需要是timestamp。
- 每次更新后都将最新时间插入到此列。
- 读取数据时，将时问读取出来，在执行更新的时候，比较时间。
- 如果相同则执行更新，如果不相同，说明此条数据已经发生了变化。

# 准备数据
create table city(
    id int primary key auto_increment,
    NAME varchar(20),
    VERSION int
);
insert into city values
(null,'北京',1),
(null,'上海',1),
(null,'广州',1),
(null,'深圳',1) ;
select * from city;

select VERSION from city where NAME='北京';
update city set NAME='北京市',VERSION=VERSION+1 where NAME='北京' and VERSION=1;

MySQL数据库一 Li.058

Thu, 14 Oct 2021 20:54:38 +0800

数据库安装和设置UTF-8

数据库安装和设置UTF-8

SQL 介绍

SQL (Structured Query Language): 结构化查询语文. 其实就是定义了操作所有关系型数据库的一种规则
通用语法规则
- SQL 语句可以单选或多行书写, 以分号结尾
- 可使用空格和缩进来增强语句的可读性
- MySQL数据库的SQL语句不区分大小写, 关键字建议使用大写
- 单选注释: – 注释内容
- 多行注释 /* 注释内容 */
SQL 分类
- DDL(Data Definition Language): 数据定义语文. 用来操作数据库,表,列等
- DML(Data Manipulation Language): 数据操作语文. 用来对数据库中表的数据进行增删改.
- DQL(Data Query Language): 数据查询语言. 用来查询数据库表的记录(数据).
- DCL(Data Control Language): 数据控制语言. 用来定义数据库的访问权限和安全级别, 及创建用户.

DDL 查询和创建数据库

# 查询所有数据库
show databases ;
# 查询数据的创建的创建语句
show create database mysql;
# 创建数据库
create database mydb;
# 创建数据库(判断,如果不存在则创建)
create database if not exists mydb2;
# 创建数据库(指定字符集)
create database mydb3 character set UTF8mb4;
# 练习创建mydb4, 不存在则创建, 并指定UTF8字符
create database if not exists mydb4 character set UTF8mb4;

DDL 修改删除使用数据库

# 修改数据库(修饰字符集)
ALTER DATABASE mydb4 CHAR SET gbk;
show create database mydb4;
# 删除数据库
drop database mydb4;
# 删除数据库(判断, 如果存在则删除)
drop database if exists mydb4;
# 使用数据库
use mydb3;
# 查看当前使用的数据库
select DATABASE();

DDL 查询数据表

# 查询所有的数据表
use mysql;
show tables ;
# 查询表结构
desc user;
# 查询表字符集
show table status from mysql like 'user';

DDL 创建数据表

格式

create table 表名(
    列名 数据类型 约束,
    列名 数据类型 约束,
    列名 数据类型 约束
);

数据类型

int:           整数类型
double:        小数类型
datetime:      日期类型.包含年月日,格式yyyy-MM-dd         HH:mm:ss
timestamp:     日间戮类型.包含年月日时分秒,格式yyyy-MM-dd HH:mm:ss(如不赋值或赋值null,默认使用系统时间赋值)
varchar(长度): 字符串类型

# 创建一个product商品表(商品编号, 商品名称, 商品价格, 商品库存, 上架时间)
create table product(
    id INT,
    name VARCHAR(20),
    price DOUBLE,
    stock INT,
    insert_time DATE
);
desc product;

DDL 修改数据表

# 修改表名
alter table product rename to newProduct;
show tables ;
# 修改表的字符集
alter table newProduct character set utf8mb4;
show table status from mydb3 like 'newProduct';
# 单独添加一列
alter table newProduct add color VARCHAR(10);
desc newProduct;
# 修改某列的数据类型
alter table newProduct modify color INT;
desc newProduct;
# 修改列名和数据类型
alter table newProduct change color address VARCHAR(200);
desc newProduct;
# 删除某一列
alter table newProduct drop address;
desc newProduct;

DDL 删除数据表

# 删除数据表
drop table product;
show tables ;
# 删除数据表(判断, 如果存在则删除)
drop table if exists newProduct;
show tables ;

DML 新增表数据

# 给指定列添加数据
desc product;
insert into product(id,name) values (1, '电饭煲');
select * from product;
# 给全部列添加数据
insert into product values (2,'iPhone',8000.0,1,null);
select * from product;
# 批量添加数据
insert into product(id,name) values (3,'XiaoMi'),(4,'Vivo');
insert into product values (5,'MacBookPro',8000.0,1,'2020-02-02'),(6,'Mac Mini',5000.0,2,'2021-06-06');
select * from product;

DML 修改和删除表数据

update和delete未加where会更新或删除全表数据

# 修改表中的数据
update product set name='高压电饭煲',price=1000 where id=1;
update product set stock=2;
select * from product;

# 删除表中的数据
delete from product where id=2 or id=3;
delete from product ;
select * from product;

DQL 表数据查询–数据准备

# 数据准备, 商品编号 商品名称 商品价格 商品品牌 商品库存 添加时间
use mydb3;
create table product(
    id INT,
    name VARCHAR(20),
    price DOUBLE,
    brand VARCHAR(10),
    stock INT,
    insert_time DATE
);
insert into mydb3.product values
(1,'华为手机',3999,'华为',23,'2088-03-10'),
(2,'小米手机',2999,'小米',30,'2088-05-15'),
(3,'苹果手机',5999,'苹果',18,'2088-08-20'),
(4,'华为电脑',6999,'华为',14,'2088-06-16'),
(5,'小米电脑',4999,'小米',26,'2088-07-08'),
(6,'苹果电脑',8999,'苹果',15,'2088-10-25'),
(7,'联想电脑',7999,'联想',null,'2088-11-11');
select * from mydb3.product;

DQL 表数据查询–查询全部

/*
select 字段列表 from 表名列表
where 条件列表
group by 分组字段
having 分组后的过滤条件
order by 排序
limit 分页;  */

# 查询全部的表数据
select * from product;
# 查询指定字段的表数据
select name,price,brand from mydb3.product;
# 去除重复查询
select brand from product;
select distinct brand from product;
# 计算列的值(四则运算)
select name,stock+10 from mydb3.product;
# 如果一列为null, 可以进行替换ifnull(表达式1,表达式2), 表达式1:想替换的列, 表达式2:想替换的值
select name,ifnull(stock,0)+10 from mydb3.product;
# 起别名查询, 别名as关键字也可以省略的
select name,ifnull(stock,0)+10 as getSum from mydb3.product;
select name,ifnull(stock,0)+10 getSum from mydb3.product;

DQL 表数据查询–条件查询

查询条件分类

符号             功能
>                大于
<                小于
>=               大于等于
<=               小于等于
=                等于
<>或!=           不等于
between...and... 在某个范围之内(都包含)
in(...)          多选一
like占位符       模糊查询_单个任意字符%多个任意字符
is.null          是null
is.not.null      不是null
and或&&          并且
or或||           或者
not或!           非,不是

条件查询语法

select 列名列表 from 表名where 条件;

# 查询库存大于20的商品信息
select * from mydb3.product where stock>20;
# 查询品牌为华为的商品信息
select * from product where brand= '华为';
# 查询金额在4000 ~ 6000 之间的商品信息
select * from product where price>=4000 and price<=6000;
select * from product where price between 4000 and 6000;
# 查询库存为14,30,23的商品信息
select * from product where stock=14 or stock=30 or stock=23;
select * from product where stock in (14,30,23);
# 查询库存为null的商品信息
select * from product where stock is null;
# 查询库存不为null的商品信息
select * from product where stock is not null;
# 查询名称以小米为开头的商品信息
select * from product where name like '小米%';
# 查询名称第二个字是是'为'的商品信息
select * from product where name like '_为%';
# 查询名称为四个字符的商品信息
select * from product where name like '____';
# 查询名称中包含电脑的商品信息
select * from product where name like '%电脑%';

DQL 表数据查询–聚合函数查询

聚合函数的介绍
- 将一列数据作为一个整体, 进行纵向的计算
聚合函数的分类

函数名      功能
count(列名) 统计数量(一般选用不为null的列)
max(列名)   最大值
min(列名)   最小值
sum(列名)   求和
avg(列名)   平均值

聚合函数查询语法
- select 函数名(列名) from 表名 [where条件];

# 计算product 表中总记录条件
select count(*) from product;
# 获取最高价格
select max(price) from product;
# 获取最低库存
select min(stock) from product;
# 获取总库存数量
select sum(stock) from product;
# 获取品牌为苹果的总库存数量
select sum(stock) from product where brand='苹果';
# 获取品牌为小米的平均商品价格
select avg(price) from product where brand='小米';

DQL 表数据查询–排序查询

排序查询语法 select 列名列表 from 表名 [where 条件] order by 列名排序方式,列名排序方式…;
排序方式
- ASC 升序
- DESC 降序
如果有多个排序条件, 只有当前边的条件值一值时, 才会判断第二条件.

# 按照库存升序排序
select * from product order by stock asc ;
# 查询名称中包含手机的商品信息, 按照金额降序排序
select * from product where name like '%手机%' order by price desc;
# 按照金额升序排序, 如果金额相同, 按照库存降序排序
update product set price=6999 where id=6;
select * from product order by price asc ,stock desc;

DQL 表数据查询–分级查询

分级查询语法
- select 列名列表 from 表名 [where 条件] group by 分级列名 [having 分级后的条件过滤] [order by 排序列名排序方式] ;

# 按照品牌分组, 获取每组商品的总金额
select  brand,sum(price) from product group by brand;
# 对金额大于4000元的商品, 按照品牌分组, 获取每组商品的总金额
select brand,sum(price) from product where price>4000 group by brand;
# 对金额大于4000元的商品, 按照品牌分组, 获取每组商品的总金额, 只显示总金额大于7000元的
select brand,sum(price) getSum from product where price>4000 group by brand having getSum>7000;
# 对金额大于4000元的商品, 按照品牌分级, 获取每组商品的总金额, 只显示总金额大于7000元的, 并按照总金额的降序排列
select brand,sum(price) getSum from product where price>4000 group by brand having getSum>7000 order by getSum desc ;

DQL 表数据查询–分页查询

分页查询语法
- select 列名列表 from 表名 [where 条件] group by 分级列名 [having 分级后的条件过滤] [order by 排序列名排序方式] limit 当前大岁数,每页显示的条数;
- 公式: 当前页数 = (当前页数-1) * 每页显示的条数

# 每页显示3条数据
# 第1页 当前页数=(1-1)*3
select * from product limit 0,3;
# 第2页 当前页数=(2-1)*3
select * from product limit  3,3;
# 第3页 当前页数=(3-1)*3
select * from product limit  6,3;

MySQL 外键约束

为什么要有外键约束
- 当表与表之间的数据有相关联性的时候, 如果没有相关的数据约束, 则无法保证数据的准确性
外键约束的作用
- 让表与表之间产生关联关系
建表时添加外键约束

create table 表名(
    列名 数据类型 约束,
    ...
    constraint 外键名 foreign key(本表外键列名) references 主表名(主表主键列名)
);

删除外键约束

alter table 表名 drop foreign key 外键名;

建表后单独添加外键约束

alter table 表名 constraint 外键名 foreign key(本表外键列名) references 主表名(主表主键列名);

## 建立数据
use mydb3;
create table USER(
    id int primary key auto_increment,
    NAME varchar(20) not null
);
insert into USER values (null,'张三'),(null,'李四');

create table orderlist(
    id int primary key auto_increment,
    number varchar(20) not null,
    uid int,
    constraint ou_fk1 foreign key (uid) references USER(id)
);
insert into orderlist values (null,'hm001',1),(null,'hm002',1),
                             (null,'hm003',2),(null,'hm004',2);
select * from orderlist;

# 添加一个订单, 但是没有真实用户
insert into orderlist values (null,'hm005',3);
# 删除李四用户
delete from USER where NAME = '李四';
# 删除外键约束
alter table orderlist drop foreign key ou_fk1;
# 添加外键约束
alter table  orderlist add constraint ou_fk1 foreign key (uid) references USER(id);

外键的级联更新和级联删除

添加级联更新

alter table 表名 constraint 外键名 foreign key(本表外键列名)
references 主表名(主表主键列名)
on update cascade;

添加级联删除

alter table 表名 constraint 外键名 foreign key(本表外键列名)
references 主表名(主表主键列名)
on delete cascade;

同时添加级联更新和级联删除

alter table 表名 constraint 外键名 foreign key(本表外键列名)
references 主表名(主表主键列名)
on update cascade on delete cascade;

# 先删除外键
alter table orderlist drop foreign key ou_fk1;
## 级联更新和删除
alter table  orderlist add constraint ou_fk1 foreign key (uid)
    references USER(id)
on update cascade on delete cascade ;
# 将李四用户id修改为3
update USER set id=3 where id=2;
select * from USER;
select * from orderlist;
# 删除李四这个用户
delete from USER where id=3;

约束

什么是约束
- 对表中的数据进行限定保证数据的正确性, 有效性, 完整性
约束的分类

约束                          | 作用
primary key                   | 主键约束
primary key auto_increment    | 主键自增
unique                        | 唯一约束
not null                      | 非空约束
foreign key                   | 外键约束
foreign key on update cascade | 外键级联更新
foreign key on delete cascade | 外键级联删除

主键约束

主键约束的特点
- 主键约束默认包含非空和唯一两个功能
- 一张表只能有一个主键
- 主键一般用于表中数据的唯一标识
建表时添加主键约束

create table 表名(
    列名 数据类型 primary key,
    ...
    列名 数据类型 约束
);

删除主键主键约束

alter table 表名 drop primary key;

键表后单独添加主键约束

alter table 表名 modify 列名 数据类型 primary key;

# 创建学生表(编号,姓名,年龄) 编号设为主键
create table student(
    id int primary key ,
    NAME varchar(50),
    age int
);
# 查询学生表的详细信息
desc student;
# 添加数据
insert into student values (null,'张三',23);
insert into student values (1,'张三',23);
insert into student values (1,'李四',24);
insert into student values (2,'李四',24);
# 删除主键
alter table student drop primary key ;
# 添加主键约束
alter table student modify id int primary key ;

主键自增约束

建表时添加主键自增约束

create table 表名(
    列名 数据类型 primary key auto_increment,
    ...
    列名 数据类型 约束
);

删除主键自增约束

alter table 表名 modify 列名 数据类型;

建表后单独添加主键自增约束

alter table 表名 modify 列名 数据类型 auto_increment;

MySQL中的自增约束,必须配合键的约束一起使用!

# 创建学生表(编号,姓名,年龄) 编号设为主键 自增
drop table student;
create table student(
    id int primary key auto_increment,
    NAME varchar(50),
    age int
);
# 查询学生表的详细信息
desc student;
# 添加数据
insert into student values (null,'张三',23);
insert into student values (null,'李四',23);
select * from student;
# 删除自增约束
alter table student modify id INT;
# 建表后单独添加自增约束
alter table student modify id INT auto_increment;

唯一约束

建表时添加唯一约束

create table 表名(
    列名 数据类型 unique,
    ...
    列名 数据类型 约束
);

删除唯一约束

alter table 表名 drop index 列名;

建表后单独添加主键自增约束

alter table 表名 modify 列名 数据类型 unique;

# 创建学生表(编号,姓名,年龄) 编号设为主键 自增 年龄唯一
drop table student;
create table student(
    id int primary key auto_increment,
    NAME varchar(50),
    age int unique
);
# 查询学生表的详细信息
desc student;
# 添加数据
insert into student values (null,'张三',23);
insert into student values (null,'李四',23);
select * from student;
# 删除唯一约束
alter table student drop index age;
desc student;
# 建表后单独添加唯一约束
alter table student modify age INT unique ;

非空约束

建表时添加非空约束

create table 表名(
    列名 数据类型 not null,
    ...
    列名 数据类型 约束
);

删除非空约束

alter table 表名 modify 列名 数据类型;

建表后单独添加非空约束

alter table 表名 modify 列名 数据类型 not null;

# 创建学生表(编号,姓名,年龄) 编号设为主键 自增 姓名非空 年龄唯一
drop table student;
create table student(
    id int primary key auto_increment,
    NAME varchar(50) not null ,
    age int unique
);
# 查询学生表的详细信息
desc student;
# 添加数据
insert into student values (null,null,24);
insert into student values (null,'张三',23);
select * from student;
# 删除非空
alter table student modify NAME VARCHAR(50);
desc student;
# 建表后单独添加非空
alter table student modify NAME varchar(50) not null ;

多表操作

多表概念
- 多张数据表, 而表与表之间是可以有一定的关联关系, 这种关联关系通过外键约束实现
多表的分类
- 一对一
- 一对多
- 多对多
一对一
- 适用场景
  - 人和身份证. 一个人只有一个身份证, 一个身份证只能对应一个人
- 建表原则
  - 在什么问题一个表建立外键, 去关联另外一个表的主键

## 一对一
use mydb3;
create table person(
  id int primary key auto_increment,
  NAME varchar(20)
);
insert into person values (null,'张三'),(null,'李四');
create  table card(
    id INT primary key auto_increment,
    number varchar(20) unique not null ,
    pid int unique,
    constraint cp_fk1 foreign key (pid) references person(id)
);
insert into card values (null,'12345',1),(null,'56789',2);

一对多
- 适用场景
  - 用户和订单. 一个用户可以有多个订单
  - 商品分类和商品. 一个分类下可以有多个商品
- 建表原则
  - 在多的一方, 建立外键约束, 来关联一的一方主键

## 一对多
use mydb3;
create table USER(
    id int primary key auto_increment,
    NAME varchar(20)
);
insert into USER values (null,'张三'),(null,'李四');

create table orderlist(
    id int primary key auto_increment,
    number varchar(20),
    uid int,
    constraint ou_fk1 foreign key (uid) references USER(id)
);
insert into orderlist values (null,'hm001',1),(null,'hm002',1),(null,'hm003',2),(null,'hm004',2);

## 一对多示例二
create table category(
    id int primary key auto_increment,
    NAEM varchar(10)
);
insert into category values (null,'手机数码'),(null,'电脑办公');
create table product(
    id int primary key auto_increment,
    NAME varchar(30),
    cid int,
    constraint pc_fk1 foreign key (cid) references category(id)
);
insert into product values (null,'华为P30',1),(null,'小米note3',1),(null,'联想电脑',2),(null,'苹果电脑',2);

多对多
- 适用场景
  - 学生和谭程. 一个学生可以选择多个课程, 一个课程也可以被多个学生选择
- 建表原则
  - 需要借助第三张中间表, 中间表至少包含2个列. 这2个列作为中间表的外键, 分别关联2张表的主键.

use mydb3;
show tables ;
create table student(
    id int primary key auto_increment,
    NAME varchar(20)
);
insert into student values (null,'张三'),(null,'李四');

create table course(
    id int primary key auto_increment,
    NAME varchar(10)
);
insert into course values (null,'语文'),(null,'数学');

create table stu_course(
    id int primary key auto_increment,
    sid int,
    cid int,
    constraint sc_fk1 foreign key (sid) references student(id),
    constraint sc_fk2 foreign key (cid) references course(id)
);
insert into stu_course values (null,1,1),(null,1,2),(null,2,1),(null,2,2);

多表查询

多表查询分类
- 内连接查询
- 外连接查询
- 子查询
- 自关联查询
多表查询数据准备

# 多表操作数据准备
create database mydb4;
use mydb4;
create table USER(
    id int primary key auto_increment,
    NAME varchar(20),
    age int
);
insert into USER values (1,'张三',23);
insert into USER values (2,'李四',24);
insert into USER values (3,'王五',25);
insert into USER values (4,'赵六',26);

create table orderlist(
    id int primary key auto_increment,
    number varchar(30),
    uid int,
    constraint ou_fk1 foreign key (uid) references USER(id)
);
insert into orderlist values (1,'hm001',1);
insert into orderlist values (2,'hm002',1);
insert into orderlist values (3,'hm003',2);
insert into orderlist values (4,'hm004',2);
insert into orderlist values (5,'hm005',3);
insert into orderlist values (6,'hm006',3);
insert into orderlist values (7,'hm007',null);

create table category(
    id int primary key auto_increment,
    NAEM varchar(10)
);
insert into category values (1,'手机数码');
insert into category values (2,'电脑办公');
insert into category values (3,'烟酒茶糖');
insert into category values (4,'靴靴箱包');
insert into category values (null,'靴靴箱包');

create table product(
    id int primary key auto_increment,
    NAME varchar(30),
    cid int,
    constraint cp_fk1 foreign key (cid) references category(id)
);
insert into product values (1,'华为手机',1);
insert into product values (2,'小米手机',1);
insert into product values (3,'联想电脑',2);
insert into product values (4,'苹果电脑',2);
insert into product values (5,'中华香烟',3);
insert into product values (6,'玉溪香烟',3);
insert into product values (7,'计生用品',null);

create table us_pro(
    upid int primary key auto_increment,
    uid int,
    pid int,
    constraint up_fk1 foreign key (uid) references USER(id),
    constraint up_fk2 foreign key (pid) references product(id)
);
insert into us_pro values (null,1,1);
insert into us_pro values (null,1,2);
insert into us_pro values (null,1,3);
insert into us_pro values (null,1,4);
insert into us_pro values (null,1,5);
insert into us_pro values (null,1,6);
insert into us_pro values (null,1,7);
insert into us_pro values (null,2,1);
insert into us_pro values (null,2,2);
insert into us_pro values (null,2,3);
insert into us_pro values (null,2,4);
insert into us_pro values (null,2,5);
insert into us_pro values (null,2,6);
insert into us_pro values (null,2,7);
insert into us_pro values (null,3,1);
insert into us_pro values (null,3,2);
insert into us_pro values (null,3,3);
insert into us_pro values (null,3,4);
insert into us_pro values (null,3,5);
insert into us_pro values (null,3,6);
insert into us_pro values (null,3,7);
insert into us_pro values (null,4,1);
insert into us_pro values (null,4,2);
insert into us_pro values (null,4,3);
insert into us_pro values (null,4,4);
insert into us_pro values (null,4,5);
insert into us_pro values (null,4,6);
insert into us_pro values (null,4,7);

内连接查询

查询原理
- 内连接查询的是两张表有交集的部分数据(有主外键关联的数据)
查询语法
- 显式内连接: select 列名 from 表名1 [inner]join 表名2 on 条件;
- 隐式内连接: select 列名 from 表名1,表名2 where 条件;

# 显式内连接查询, 查询用户信息和对应的订单信息
select * from USER inner join orderlist on USER.id = orderlist.uid;
# 查询用户信息和对应的订单信息, 起别名
select * from USER as u inner join orderlist as o on u.id = o.uid;
# 查询用户姓名, 年龄 和 订单编号
select
    u.NAME,
    u.age,
    o.number
from
    USER u
        inner join
    orderlist o
    on
            u.id = o.uid;

# 隐式内连接, 查询用户姓名, 年龄 和 订单编号
select
    u.NAME,
    u.age,
    o.number
from
    USER u,
    orderlist o
where
        u.id = o.uid;

外连接查询

左外连接
- 查询原理: 查询左表的全部数据, 和左右两张表有交集部分的数据
- 查询语法: select 列名 from 表名1 left [outer] join 表名2 on 条件;
右外连接
- 查询原理: 查询右表的全部数据, 和左右两张表有交集部分的数据
- 查询语法: select 列名 from 表名1 right [outer] join 表名2 on 条件;

# 查询语法: select 列名 from 表名1 left [outer] join 表名2 on 条件;
select
    u.*,o.number
from
    USER u
        left join
    orderlist o
    on u.id = o.uid;
# 查询语法: select 列名 from 表名1 right [outer] join 表名2 on 条件;
select
    o.*,u.name
from
    USER u
        right join
    orderlist o
    on u.id = o.uid;

子查询

子查询概念
- 查询语句中嵌套了查询语句, 我们就将嵌套的查询称为子查询.
结果是单行单列的
- 查询作用: 可以将查询的结果作用为另一条语句的查询条件, 使用运算符判断. =»=«=等.
- 查询语法: select 列名 from 表名 where 列名=(select 列名from 表名 [where 条件])

# 查询年龄最高的用户姓名
select * from USER;
select name,max(age) from USER; # 错误使用
select NAME,age from USER where age=(select max(age) from USER);

结果是多行单列的
- 查询作用: 可以作为条件, 使用运算符IN或NOT IN进行判断
- 查询语法: select 列名 from 表名 where 列名 [not] in (select 列名 from 表名 [where 条件]);

# 查询张三和李四的订单信息
select * from orderlist where uid in (1,2);
select id from USER where NAME in ('张三','李四');
select * from orderlist where uid in (select id from USER where NAME in ('张三','李四'));

结果是多行多列的
- 查询作用: 查询结果可以作为一张虚拟表参与查询
- 查询语法: select 列名 from 表名 [别名],(select 列名 from 表名 [where条件]) [别名][where 条件];

# 查询订单表中id大于4的订单信息和所属用户信息
select * from orderlist where id>4;
select
    u.name,
    o.number
from
    USER u,
     (select * from orderlist where id>4) o
where
    o.uid = u.id;

自关联查询

自关联查询
- 在同一张表中数据有关联性, 我们可以把这张表当成多个表来查询

# 创建数据
create table employee(
    id int primary key auto_increment,
    NAME varchar(20),
    mgr int,
    salary double
);
insert into employee values
(1001,'孙悟空',1005,9000.00),
(1002,'猪八戒',1005,8000.00),
(1003,'沙和尚',1005,8500.00),
(1004,'小白龙',1005,7900.00),
(1005,'唐僧',null,15000.00),
(1006,'武松',1009,7600.00),
(1007,'李逵',1009,7400.00),
(1008,'林冲',1009,8100.00),
(1009,'宋江',null,16000.00);
# 查询所有员工的姓名及其直接上级的姓名, 没有上级的员工也需要查询
# empployee.mgr = employee.id
# 左表的全部数据, 和左右2张表有交集的部分, 左外连接
select
    e1.id,
    e1.NAME,
    e1.mgr,
    e2.id,
    e2.NAME
from
    employee e1
        left join
    employee e2
    on
            e1.mgr=e2.id;

多表查询练习

搞清哪几个表

表之间的连接方式

left join 不能与 on和where后and联用,会不起作用

# 查询用户的编号,姓名,年龄,订单编号
select u.id,u.NAME,u.age, o.number
from USER u inner join orderlist o
on u.id=o.uid;
select u.id,u.NAME,u.age, o.number
from USER u, orderlist o
where u.id=o.uid;
# 查询所有的用户. 用户的编号,姓名,年龄,订单编号
select u.id,u.NAME,u.age,o.number
from USER u left join orderlist o
on u.id=o.uid;
# 查询所有的订单. 用户的编号,姓名,年龄,订单编号
select u.id,u.NAME,u.age,o.number
from USER u right join orderlist o
on u.id=o.uid;
# 查询用户年龄大于23岁的信息. 显示用户的编号,姓名,年龄,订单编号
select u.id,u.NAME,u.age,o.number
from
    (select * from USER where age>23) as u,
    orderlist o
where u.id = o.uid;
select u.id,u.NAME,u.age,o.number
from USER u ,orderlist o
 where u.id = o.uid and u.age>23;
# 查询张三和李四用户的信息. 显示用户的编号,姓名,年龄,订单编号
select u.id,u.NAME,u.age,o.number
from USER u inner join orderlist o on u.id = o.uid and u.NAME in ('张三','李四');
# 查询商品分类的编号,分类名称,分类下的商品名称
select c.id,c.NAEM,p.NAME
from category c ,product p
where c.id = p.cid;
# 查询所有的商品分类. 商品分类的编号,分类名称,分类下的商品名称
select c.id,c.NAEM,p.NAME
from category c left join product p
on c.id = p.cid;
# 查询所有的商品信息. 商品分类的编号,分类名称,分类下的商品名称
select c.id,c.NAEM,p.NAME
from category c right join product p
on c.id = p.cid;
# 查询所有用户和所有的商品. 显示用户的编号,姓名,年龄,商品名称
# USER product us_pro中间表
# 条件 USER.id=us_pro.uid and us_pro.pid = product.id
select u.id,u.NAME,u.age,p.NAME
from USER u, product p, us_pro up
where u.id = up.uid and p.id = up.pid;
# 查询张三和李四这2个用户可以看到的商品. 显示用户的编号,姓名,年龄,商品名称
# USER product us_pro中间表
# 条件 USER.id=us_pro.uid and us_pro.pid = product.id and USER.NAME in ('张三','李四')
select u.id,u.NAME,u.age,p.NAME
from USER u, product p, us_pro up
where u.id = up.uid and p.id = up.pid and u.NAME in ('张三','李四');

JavaWeb核心四 Li.057

Wed, 13 Oct 2021 14:42:33 +0800

EL 表达式

EL (Expression Language): 表达式语言.
在JSP 2.0规范中加入的内容, 也是Servlet规范的一部分.
作用: 在JSP页面中获取数据. 让我们的JSP脱离java代码块和JSP表达式

<%--请求域中添加username数据--%>
<% request.setAttribute("username","zhangsan"); %>

<%--获取请求域的username 3种方式--%>

<%--Java代码块--%>
<% out.println(request.getAttribute("username")); %> <br/>

<%--JSP表达式获取--%>
<%= request.getAttribute("username")%> <br/>

<%--EL表达式获取--%>
${username}

EL 表达式获取数据类型

获取基本数据类型的数据
获取自定义对象类型的数据
获取数组类型的数据
获取List集合类型的数据
获取Map集合类型的数据

<%@ page import="com.lizicai.bean.Student" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.HashMap" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<% pageContext.setAttribute("num",10); %>
基本数据类型 ${num} <br/>

<% Student stu = new Student("李明", 23);
pageContext.setAttribute("stu",stu);
%>
自定义对象: ${stu} <br/>
${stu.name}
${stu.age}  <br/>

<%
    String[] arr = {"Haha", "go"};
    pageContext.setAttribute("arr",arr);
%>

数组: ${arr} <br/>
${arr[0]} ${arr[1]} ${arr[2]} <br/>


<%
    ArrayList<String> list = new ArrayList<>();
    list.add("aaa");
    list.add("bbb");
    pageContext.setAttribute( "list",list);
%>
List集合 ${list}  ${list[0]} <br/>

<%
    HashMap<String, Student> map = new HashMap<>();
    map.put("s01",new Student("李明",20));
    map.put("s02",new Student("张三",20));
    pageContext.setAttribute( "map",map);
%>
Map 集合: ${map} <br/>
第一个学生 ${map.s01} <br>
第一个学生的姓名 ${map.s01.name} <br>
</body>
</html>

EL 表达式注意事项

EL 表达式没有空指针异常
EL 表达式没有索引越界异常
EL 表达式没有字符串的拼接

<%
    Student s = null;
    String [] arr2 = {"Hello", "World"};
    pageContext.setAttribute( "s",s);
    pageContext.setAttribute( "arr2",arr2);
%>
${s}
${arr2[10]}
${arr2[0]}+${arr2[1]}

EL 表达式运算符

关系运算符

关系运算符 作用     示例 结果
==或eq     等于     略   略
!=或ne     不等于   略   略
<或lt      小于     略   略
>或gt      大于     略   略
<=或le     小于等于 略   略
>=或ge     大于等于 略   略

逻辑运算符

运算符  作用 示例 结果
&&或and 并且 略   略
||或or  或者 略   略
!或not  取反 略   略

其他运算符

运算符               作用
empty                1判断对象是否为null.2判断字符串是否为空字符串.3判断窗口元素是否为0
条件?表达式1:表达式2 三元运算符

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>EL 表达式运算符</title>
</head>
<body>
<%
    String ss = null;
    String ss2 = "";
    int[] arr = {};
%>
${empty ss} <br/>
${empty ss2} <br/>
${empty arr} <br/>

<% pageContext.setAttribute("gender", "man"); %>
<input type="radio" name="gender" value="man" ${gender == "man" ? "checked" : ""}> 男
<input type="radio" name="gender" value="woman" ${gender == "woman" ? "checked" : ""}> 女
</body>
</html>

EL 表达式使用细节

EL 表达式能够获取四大域对象的数据, 根据名称从小到大在域对象中查找.
还可以获取JSP其他八个隐式对象, 并调用对象中的方法.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

<%
    pageContext.setAttribute("username", "zhangsan1");
    request.setAttribute("username", "zhangsan2");
    session.setAttribute("username", "zhangsan3");
    application.setAttribute("username", "zhangsan4");
%>
${username} <br>

<%= request.getContextPath() %>
${pageContext.request.contextPath}

</body>
</html>

EL 表达式隐式对象

隐式对象名称     对应JSP隐式对象 说明
pageContext      pageContext     功能完全相同
applicationScope 没有            操作应用域对象数据
sessionScope     没有            操作会话域对象数据
requestScop      没有            操作请求域对象数据
pageScope        没有            操作页面域对象数据
header           没有            操作请求头数据
headerValues     没有            获取请求头数据(多个值)
param            没有            获取请求参数数据
paramValues      没有            获取请求参数数据(多个值)
initParam        没有            获取全局配置参数数据
cookie           没有            获取Cookie 对象

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

<%-- pageContext 对象, 可以获取其他3个域对象和JSP中八个隐式对象--%>
${pageContext.request.contextPath} <br/>

<%--applicationScope sessionScope requestScop pageScope--%>
<% request.setAttribute("username", "zhangsan1"); %>
<% pageContext.setAttribute("username", "zhangsan2"); %>
${username} <br/>
${requestScope.username} <br/>
${pageScope.username} <br/>

<%--header headerValues 获取的数组--%>
${header["connection"]} <br>
${headerValues["connection"][0]} <br>


<%--param paramValues 获取请求参数--%>
${param.username} <br/>
${paramValues.hobby[0]} <br/>
${paramValues.hobby[1]} <br/>


<%--initParam 获取全局配置参数--%>
${initParam.pname} <br>


<%--cookie--%>
${cookie} <br>
${cookie.JSESSIONID} <br>  <%-- 获取集合元素--%>
${cookie.JSESSIONID.name} <br> <%-- 获取cookie对象的名称 --%>
${cookie.JSESSIONID.value} <br>  <%-- 获取cookie对象的数据值 --%>

</body>
</html>

JSTL 介绍

JSTL (Java Servler Pages Standarded Tag Library): JSP标准标签库
主要提供给开发人员一个标准通用的标签库
开发人员可以利用这些标签取代JSP页面上的Java代码, 从而提高程序的可读性, 降低程序的维护难度.

组成      作用       说明
core      核心标签库 通用的逻辑处理
fmt       国际化     不同地域显示不同语言
functions EL函数     EL表达式可以使用的方法
sql       操作数据库 了解
xml       操作XML    了解

JSTL 核心标签库

标签名称           功能分类         属性       作用
<标签名:if>        流程控制         核心标签库 用于条件判断
<标签名:choose>    ifelseif流程控制 核心标签库 用于多条件判断
<标签名:when>      ifelseif流程控制 核心标签库 用于多条件判断
<标签名:otherwise> ifelseif流程控制 核心标签库 用于多条件判断
<标签名:forEach>   迭代遍历         核心标签库 用于循环遍历

http://archive.apache.org/dist/jakarta/taglibs/standard/binaries/解压lib的包导入tomcatlib中

<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="ss" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSTL演示</title>
</head>
<body>
${pageContext.setAttribute("score","A")}
<ss:if test="${score eq 'F'}">
    优秀
</ss:if>

<ss:choose>
    <ss:when test="A">优</ss:when>
    <ss:when test="B">良</ss:when>
    <ss:when test="C">及格</ss:when>
    <ss:otherwise>成绩不合法</ss:otherwise>
</ss:choose>
</body>
</html>

<%@ taglib prefix="ss" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%
    ArrayList<String> list = new ArrayList<>();
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    pageContext.setAttribute("list",list);
%>
<ss:forEach  items="${list}" var="str">
    ${str} <br>
</ss:forEach>

</body>
</html>

过滤器介绍

在程序中访问服务器资源时, 当一个请求到来, 服务器首先判断是否有过滤器与请求资源相关联
如果有, 过滤器可以将请求拦截下来, 完成一些特定的功能, 再由过滤器决定是否交给请求资源
如果没有, 则像之前那样直接请求资源了. 响应也是类似
过滤器一般用于完成通用的操作, 例如: 登录验证, 统一编码处理,敏感字符过滤等等``````

Filter

Filter 是一个接口. 如果想实现过滤器的功能, 必须实现该接口
核心方法

返回值 方法名                                                                      作用
void   init(FilterConfig.filterConfig)                                             初始化方法
void   doFilter(ServletRequest.request,ServletResponse.response,FilterChain.chain) 对请求资源和响应资源过滤
void   destroy()                                                                   销毁方法

配置方法
- 注解方式
- 配置文件

FilterChain

FilterChain 是一个接口, 代表过滤器链对象. 由Servlet容器提供实现类对象. 直接使用即可.
过滤器可以定义多个, 就会组成过滤器链
核心方法

返回值 方法名 作用
void doFilter(ServletRequest.request,ServletResponse.response) 放行方法

如果有多个过滤器, 在第一个过滤器中调用下一个过滤器, 依次类推. 走到访问最终资源 如果只有一个过滤器, 放行时, 就会直接到达最终访问资源

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet ( value = "/demo1Filter")
public class Demo1Filter extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Demo1Filter 执行了...");
        resp.getWriter().write("Demo1Filter 执行了...");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter("/*")
public class Filter implements javax.servlet.Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("Filte");

        servletResponse.setContentType("text/html;charset=UTF-8");

        filterChain.doFilter(servletRequest,servletResponse);
    }
}

过滤器使用细节

配置方式
- 注解方式 @WebFilter(拦截路径)
- 配置文件方式

<filter>
    <filter-name>filter2</filter-name>
    <filter-class>com.lizicai.filter.Filter2</filter-class>
</filter>
<filter-mapping>
    <filter-name>filter2</filter-name>
    <url-pattern>/demo2Filter</url-pattern>
</filter-mapping>

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet ( value = "/demo2Filter")
public class Demo2Filter extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Demo2Filter 执行了...");
        resp.getWriter().write("Demo2Filter 执行了...");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

public class Filter2 implements javax.servlet.Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("Filte");

        servletResponse.setContentType("text/html;charset=UTF-8");

        filterChain.doFilter(servletRequest,servletResponse);
    }
}

多个过滤器使用顺序
- 如果有多个过滤器, 取决于过滤器映射的顺序

<filter>
    <filter-name>filter2</filter-name>
    <filter-class>com.lizicai.filter.Filter2</filter-class>
</filter>
<filter-mapping>
    <filter-name>filter2</filter-name>
    <url-pattern>/demo2Filter</url-pattern>
</filter-mapping>
<filter>
    <filter-name>filter3</filter-name>
    <filter-class>com.lizicai.filter.Filter3</filter-class>
</filter>
<filter-mapping>
    <filter-name>filter3</filter-name>
    <url-pattern>/demo3Filter</url-pattern>
</filter-mapping>

过滤器生命周期

创建
- 当应用加载时实例化对象并执行init初始化方法
服务
- 对象提供服务的过程, 执行doFilter方法
销毁
- 当应用卸载时或服务器停止时对象销毁. 执行detory()方法.

import javax.servlet.*;
import javax.servlet.Filter;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

/**
 * 过滤器生命周期
 */

@WebFilter("/demo3Filter")
public class Filter3 implements javax.servlet.Filter {

    /**
     * 初始化方法
     * @param filterConfig
     * @throws ServletException
     */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("对象初始化成功了");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("Filte");

        servletResponse.setContentType("text/html;charset=UTF-8");

        filterChain.doFilter(servletRequest,servletResponse);
    }

    /**
     * 对象销毁
     */
    @Override
    public void destroy() {
        System.out.println("对象销毁了");
    }
}

FilterConfig 介绍

FilterConfig是一个接口. 代表过滤器的配置对象, 可以加载一此初始化参数.
核心方法

返回值              方法名                        作用
String              getFilterName()               获取过滤器对象名称
String              getInitParameter(String.name) 根据key获取value
Enumeration<String> getInitParameterNames()       获取所有参数的key
ServletContext      getServletContext()           获取应用上下文对象

<filter>
    <filter-name>filter4</filter-name>
    <filter-class>com.lizicai.filter.Filter4</filter-class>
    <init-param>
        <param-name>username</param-name>
        <param-value>xiaoming</param-value>
    </init-param>
</filter>
    <filter-mapping>
    <filter-name>filter4</filter-name>
    <url-pattern>/demo4Filter</url-pattern>
</filter-mapping>

过滤器五种拦截行为

Filter过滤器默认拦截的是请求, 但是在实际开发中, 我们还有请求转发和请求包含, 以及由服务器触发的全局错误页面.
默认情况下过滤器是不参与过滤的, 要想使用, 就需要我们配置
拦截方式

    <filter>
        <filter-name>filter5</filter-name>
        <filter-class>com.lizicai.filter.Filter5</filter-class>
        <async-supported>true</async-supported>
    </filter>
    <filter-mapping>
        <filter-name>filter5</filter-name>
        <url-pattern>/index.jsp</url-pattern>

<!--        过滤请求, 默认值-->
        <dispatcher>REQUEST</dispatcher>

<!--        过滤全局错误页面-->
        <dispatcher>ERROR</dispatcher>

<!--        过滤转发-->
        <dispatcher>FORWARD</dispatcher>

<!--        当请求包含时, 过滤器工作, 只能过滤动态包含. JSP 的include是静态包含, 过滤器不会过滤-->
        <dispatcher>INCLUDE</dispatcher>

<!--        过滤异步类型, 它要求我们在filter标签中配置开启异步支持-->
        <dispatcher>ASYNC</dispatcher>
    </filter-mapping>
    <error-page>
        <exception-type>java.lang.Exception</exception-type>
        <location>/error.jsp</location>
    </error-page>
    <error-page>
        <error-code>404</error-code>
        <location>/error.jsp</location>
    </error-page>

监听器介绍

观察者设计模式, 所有的监听器都是基于观察者设计模式的
三个组成部分
- 事件源: 触发事件的对象
- 事件: 触发的动作, 封装了事件源
- 监听器: 当事件源触发事件后, 可以完成功能
在程序当中, 我们可以地: 对象的创建销毁, 域对象中属性的变化, 会话相关内容进行监听
Servlet 规范中共计8个监听器, 监听器都是以接口形式提供, 具体功能需要我们自己来完成.

监听对象的监听器

ServletContextListener: 用于咋啦ServletContext对象的创建和销毁
核心方法

返回值 方法名                                      作用
void   contextInitialized(ServletContextEvent.sce) 对象创建时执行该方法
void   contextDestroyed(ServletContextEvent.sce)   对象销毁时执行该方法

参数: ServletContextEvent代表事件对象

事件对象中封装了事件源,也就是ServletContext

真正的事件指的是创建或销毁ServletContext对象的操作

HttpSessionListener: 用于监听HttpSession对象的创建和销毁
核心方法

返回值 方法名                                作用
void   sessionCreated(HttpSessionEvent.se)   对象创建时执行该方法
void   sessionDestroyed(HttpSessionEvent.se) 对象销毁时执行该方法

参数: Httpsessionevent代表事件对象

事件对象中封装了事件源,也就是Httpsession

真正的事件指的是创建或销毁Httpsession对象的操作

ServletRequesListener: 用于监听ServletRequest对象的创建和销毁
核心方法

返回值 方法名                                      作用
void   requestInitialized(ServletRequestEvent.sre) 对象创建时执行该方法
void   requestDestroyed(ServletRequestEvent.sre)   对象销毁时执行该方法

参数: ServletRequestEvent代表事件对象

事件对象中封装了事件源,也就是ServletRequest

真正的事件指的是创建或销毁ServletRequest对象的操作

监听域对象属性变化的监听器

ServletContextAttributeListener: 用于监听ServletContext应用域属性的变化
核心方法

返回值 方法名                                               作用
void   attributeAdded(ServletContextAttributeEvent.scae)    域中添加属性时执行该方法
void   attributeRemoved(ServletContextAttributeEvent.scae)  域中移除属性时执行该方法
void   attributeReplaced(ServletContextAttributeEvent.scae) 域中替换属性时执行该方法

参数: ServletContextAttributeEvent代表事件对象

事件对象中封装了事件源,也就是ServletContext

真正的事件指的添加, 移除, 替换应用域中属性的操作

HttpSessionAttributeListenen: 用于监听HttpSession会话域中属性的变化
核心方法

返回值 方法名                                        作用
void   attributeAdded(HttpSessionBindingEvent.se)    域中添加属性时执行该方法
void   attributeRemoved(HttpSessionBindingEvent.se)  域中移除属性时执行该方法
void   attributeReplaced(HttpSessionBindingEvent.se) 域中替换属性时执行该方法

参数: HttpSessionBindingEvent代表事件对象

事件对象中封装了事件源,也就是HttpSession

真正的事件指的添加, 移除, 替换会话域中属性的操作

ServletRequestAttributeListener: 用于监听ServletRequest请求域中属性的变化
核心方法

返回值 方法名                                               作用
void   attributeAdded(ServletRequestAttributeEvent.srae)    域中添加属性时执行该方法
void   attributeRemoved(ServletRequestAttributeEvent.srae)  域中移除属性时执行该方法
void   attributeReplaced(ServletRequestAttributeEvent.srae) 域中替换属性时执行该方法

参数: ServletRequestAttributeEvent代表事件对象

事件对象中封装了事件源,也就是ServletRequest

真正的事件指的添加, 移除, 替换请求域中属性的操作

监听会话相关的感知型监听器

HttpSessionBindingListener: 用于感知对象和会话域绑定的监听器
核心方法

返回值 方法名                                      作用
void   valueBound(HttpSessionBindingEvent.event)   数据添加到会话域中(绑定)时执行该方法
void   valueUnBound(HttpSessionBindingEvent.event) 数据从会话域移除(解绑)时执行该方法

参数: HttpSessionBindingEvent 代表事件对象

事件对象中封装了事件源, 也就是HttpSession

真正的事件指的是添加, 移除会话域中数据的操作

HttpSessionActivationListener: 用于感知会话域中对象钝化和活化的监听器
核心方法

返回值 方法名                                    作用
void   sessionWillPassivate(HttpSessionEvent.se) 会话域中数据钝化时执行该方法
void   sessionWillActivate(HttpSessionEvent.se)  会话域中数据活化时执行该方法

参数: HttpSessionEvent代表事件对象

事件对象中封装了事件源, 也就是HttpSession

真正的事件指的是会话域中数据钝化, 活化的操作

监听器的使用

监听对象的
- ServletContextListener
- HttpSessionListener
- ServletRequestListener
监听属性变化的
- ServletContextAttributeListener
- HttpSessionAttributeListener
- ServletRequestAttributeListener
会话相关的感知
- HttpSessionBindingListener
- HttpSessionActivationListener

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class ServletContextListenerDemo implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("监听到对象的创建...");
        ServletContext servletContext = sce.getServletContext();
        System.out.println(servletContext);
        // 更改ServletContext 属性监听
        servletContext.setAttribute("username", "zhangsan");

        servletContext.setAttribute("username","liming");

        servletContext.removeAttribute("username");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("监听到对象的销毁...");

    }
}

import javax.servlet.ServletContext;
import javax.servlet.ServletContextAttributeEvent;
import javax.servlet.ServletContextAttributeListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class ServletContextAttributeListenerDemo implements ServletContextAttributeListener {
    @Override
    public void attributeAdded(ServletContextAttributeEvent event) {
        System.out.println("监听到应用域对象添加...");
        ServletContext servletContext = event.getServletContext();
        Object value = servletContext.getAttribute("username");
        System.out.println(value);
    }

    @Override
    public void attributeRemoved(ServletContextAttributeEvent event) {
        System.out.println("监听到应用域对象删除...");
        ServletContext servletContext = event.getServletContext();
        Object value = servletContext.getAttribute("username");
        System.out.println(value);
    }

    @Override
    public void attributeReplaced(ServletContextAttributeEvent event) {
        System.out.println("监听到应用域对象替换...");
        ServletContext servletContext = event.getServletContext();
        Object value = servletContext.getAttribute("username");
        System.out.println(value);
    }
}

配置文件方式

<listener>
    <listener-class>com.lizicai.listener.ServletContextAttributeListenerDemo</listener-class>
</listener>
<listener>
    <listener-class>com.lizicai.listener.ServletContextListenerDemo</listener-class>
</listener>

学生管理系统优化

解决乱码
- 使用过滤器实现所有资源的编码统一
检查登录
- 使用过滤器实现校验是否登录问题
优化JSP页面
- 通过EL表达和JSTL替换之前的Java代码块和JSP表达式

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebFilter("/*")
public class FilterEncodingUTF8 implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
//        请求和响应对象转换为 HTTP 协议相关
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

//        设置编码格式
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");

//        放行
        filterChain.doFilter(request,response);
    }
}

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebFilter( value = {"/addStudent.jsp", "/listStudent.jsp"})
public class FilterLogin implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
//        1. 请求和响应对象转换为 HTTP 协议相关
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

//        2. 获取会话域对象中数据
        Object name = request.getSession().getAttribute("username");

//        3. 判断用户名
        if( name == null || "".equals(name)){
//            resp.setContentType("text/html;charset=UTF-8");
            response.getWriter().write("未登录, 跳转到登录页面...");
            response.setHeader("Refresh", request.getContextPath()+"2;URL=/stuLogin.jsp");
            return;
        }

//        放行
        filterChain.doFilter(request,response);

    }
}

最后一个优化, 项目是03_JavaWeb_test4

JavaWeb核心三 Li.056

Fri, 08 Oct 2021 10:39:35 +0800

属性名  作用                   是否重要
name    Cookie的名称           必须属性
value   Cookie的值(不支持中文) 必须属性
path    Cookie的路径           重要
domain  Cookie的域名           重要
maxAge  Cookie的存活时间       重要
version Cookie的版本号         不重要
comment Cookie的描述           不重要

方法名                           作用
Cookie(String.name,String.Value) 构造方法创建对象
属性对应的set和get就去           赋值和获取值

Cooke 添加和获取

添加 HttpServletResponse

返回值 方法名                   说明
void   addCookie(Cookie.cookie) 向客户端添加Cookie

获取 HttpServletRequest

返回值   方法名       说明
Cookie[] getCookies() 获取所有的Cookie

数量限制
- 每个网站最多只能有20个Cookie, 且大小不能超过4KB. 所有网站的Cookie总数不能超过300个
名称限制
- Cookie的名称只能包含ASCCI码表中字母,数字字符. 不能包含逗号,分号,空格, 不能以$开头
- Cookie的值不支持中文
存活时间限制setMaxAge()方法接收数字
- 负整数: 当前会放有效, 浏览器关闭则清除
- 0: 立即清除
- 正整数: 以秒为单位设置存活时间
访问路径限制
- 默认路径: 取自第1次访问的资源路径前缀. 只要以这个路径开头就能访问到
- 设置路径: setPath()方法设置指定路径

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;

@WebServlet ( value = "/demo1Cookie")
public class Demo1Cookie extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=UTF-8");
        PrintWriter pw = resp.getWriter();
        pw.write("欢迎访问本网站, 你的最后访问时间为:");

        Cookie cookie = new Cookie("time", System.currentTimeMillis()+"");
        cookie.setMaxAge(10);

        resp.addCookie(cookie);

        Cookie[] arr = req.getCookies();
        for(Cookie c : arr){
            if("time".equals(c.getName())){
                String value = c.getValue();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                pw.write(sdf.format(new Date(Long.parseLong(value))));
            }
        }

    }
}

HttpSession 介绍

HttpSession: 服务器端会话管理技术
- 本质也采用客户端会话管理技术
- 只不过在客户保存一个特殊标识, 而共享的数据保存到了服务端的内存对象中.
- 第次请求时, 会将特殊标识带到服务器端, 根据这个标识来找到对应的内存空间, 从而实现数据共享.
- 是Servlet规范中四大域对象之一的会话域对象
作用: 可以实现数据共享

域对象         功能   作用
ServletContext 应用域 在整个应用之间实现共享数据
ServletRequest 请求域 在当前的请求或请求转发之间实现数据共享
HttpSession    会话域 在当前会话范围之间实现数据共享

HttpSession 常用方法

返回值 方法名                                 说明
void   setAttribute(String.name,Object.value) 设置共享数据
Object getAttribute(String.name)              获取共享数据
void   removeAttribute(String.name)           移除共享数据
String getId()                                获取唯一标识名称
void   involidate()                           让session立即失效

HttpSession 获取

返回值      方法名                     说明
HttpSession getSession()               获取HttpSession对象
HttpSession getSession(boolean.create) 获取HttpSession,未获取到是否自动创建

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

@WebServlet( value = "/demo1Session")
public class Demo1Session extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username = req.getParameter("username");
        HttpSession session = req.getSession();
        System.out.println(session);
        System.out.println(session.getId());
        session.setAttribute("username",username);
    }
}

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

@WebServlet( value = "/demo2Session")
public class Demo2Session extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();

        System.out.println(session);

        System.out.println(session.getId());

        Object username = session.getAttribute("username");

        resp.getWriter().write(username+"");
    }
}

禁用Cookie 就获取不到了
可以使用手动拼接链接

resp.getWriter().write("<a href='"+resp.encodeURL("http://localhost:8080/demo3Session")+"'>go to servlet</a>");

HttpSession 的细节

浏览器禁用Cookie, 禁止访问
手动拼接URL, 不推荐
钝化和泛化
- 什么是钝化和活化
  - 钝化: 序列化. 把长时间不用, 但还不到过期时间的HttpSession进行序列化, 写到磁盘上
  - 活化: 相反动作
- 何时钝化
  - 每一种情况: 当访问量很大时, 服务器会根据getLastAccessTime来进行排序,对长时不用,还没过期的HttpSession进行序列化
  - 第二种飞速: 当服务器进行重启的时候, 为了保持客户HttpSession中的数据, 也要对其序列化.
- 注意
  - HttpSession的序列化由服务器自动完成, 无需关心

JSP 介绍

JSP(Java Server Pages): 是一种动态见面技术标准
JSP部署在服务器上, 可以处理客户端发送的请求, 并根据请求内容动态的生成HTML,XML,或其他格式文件的Web见面, 然后再响应给客户端
JSP是基于Java语文的, 它的本质就是Servlet

类别       使用场景
HTML       开发静态资源,无法添加动态资源
CSS        美化页面
JavaScript 给网页添加一些动态效果
Servlet    编写Java代码,实现抬功能处理
JSP        包含显示页面技术,也具备Java代码功能

JSP 执行过程

JSP 语法

JSP 注释
Java 代码块
JSP 表达式
JSP 声明

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

<%--这是一行注释--%>

<%--输出在控制台上--%>
<% System.out.println("Hello");%>
<%--输出在页面上, out是jspWriter对象--%>
<% out.println("Hello<br>"); %>
<%
String str = "World";
out.println(str);
%>
<br/>

<%--JSP表达式,等效out.println--%>
<%="Hello World<br>"%>

<%--JSP声明, !是成员变量, 不加是局部方法变量, 方法里不能再定义方法 --%>
<%! String s = "AAAA<br>"; %>
<%=s%>
<%! public void he(){} %>
<%--<% public void hehe(){}%>--%>

</body>
</html>

JSP 指令

page 指令

<%@ page 属性名=属性值 属性名=属性值... %>

属性名       作用
contentType  响应正文支持的类型和设置编码格式
language     使用的语文,默认使用java
errorPage    当前页面出现异常后跳转的页面
isErrorPage  是否抓住异常,如果为true则页面中就可以使用异常对象,默认是false
import       展示导包import="java.util.ArrayList"
session      是否创建HttpSession对象,默认是true
buffer       设置JspWriter输入jsp内容缓存的大小,默认8kb
pageEncoding 翻译jsp时所用的编码格式
isElgnored   是否忽略EL表达式,默认false

<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" errorPage="error.jsp"  %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<% int a = 1/0; %>

<% ArrayList<String> s = new ArrayList<>(); %>
</body>
</html>

include 指令: 可以包含页面

<%@include file=包含的页面 %>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%! String str = "Hahaha"; %>

</body>
</html>

<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" errorPage="error.jsp"  %>
<%@ include file="include.jsp"%>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%--<% int a = 1/0; %>--%>

<% ArrayList<String> s = new ArrayList<>(); %>

<%--引入include.jsp, 可使用其中参数--%>
<%=str%>
</body>
</html>

taglib 指令: 可以引入外部标签库

<%@ taglib uri=标签库的地址 prefix=前缀名称 %>

JSP 细节

九大隐式对象

隐式对象名称 代表实际对象
request      javax.servlet.http.HttpServletRequest
reponse      javax.servlet.http.HttpServletResponse
session      javax.servlet.http.HttpSession
application  javax.servlet.ServletContext
page         java.lang.Object
config       java.servlet.ServletConfig
exception    java.lang.Throwable
out          javax.servlet.jsp.JspWriter
pageContext  javax.servlet.jsp.PageContext

PageContext 对象
- 是JSP独有的, Servlet中没有
- 是四大域对象之一的页面域对象, 还可以操作其他三个域对象中的属性
- 还可以获取其他八个隐藏对象
- 生命周期随着JSP的创建而存在,随着JSP的结束而消失. 每个JSP页面都有一个PageContext对象.
四大域对象

域对象名称 范围 级别 备注
PageContext 页面范围 最小,只能在当前页面用 国范围太小,开发中用的小
ServletRequest 请求范围 一次请求或当前请求转发用 请求转发之后,再次转发时请求域丢失
HttpSession 会话范围 多次请求数据共享使用 多次请求共享数据,但不同的客户端不能共享
ServletContext 应用范围 最大整个应用都可以使用 尽量少用,如果对数据有修改需要做同步处理

MVC 模型

M(Model): 模型. 用于封装数据, 封装的是数据模型
V(View): 视图. 用于显示数据, 动态资源用JSP页面, 静态资源用HTML页面
C(Controller): 控制器. 用于处理请求和响应, 例如Servlet

学生管理

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>index</title>
</head>
<body>
    <%
        Object username = session.getAttribute("username");
        if( username == null){
    %>
    <a href="/stuLogin.jsp" >请求登录</a>
    <% } else { %>
    <a href="/addStudent.jsp">添加学生</a>
    <a href="/listStudentServlet">查看学生</a>
    <% } %>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="/loginServlet" method="get" autocomplete="off">
    <label for="username">账户名称:</label>
    <input type="text" name="username" id="username">
    <br/>
    <label for="password">账户密码:</label>
    <input type="password" name="password" id="password">
    <br/>
    <button type="submit">登录</button>
</form>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>添加学生</title>
</head>
<body>
<form action="/addStudent" method="get" autocomplete="off">
    <label for="username">学生姓名:</label>
    <input type="text" name="username" id="username">
    <br/>
    <label for="age">学生年龄:</label>
    <input type="text" name="age" id="age">
    <br/>
    <label for="chenji">学生成绩:</label>
    <input type="text" name="chenji" id="chenji">
    <br/>
    <button type="submit">添加</button>
    <button type="reset">重置</button>
</form>
</body>
</html>

<%@ page import="java.util.ArrayList" %>
<%@ page import="com.lizicai.bean.Student" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>学生列表</title>
</head>
<body>
<%
Object name = session.getAttribute("username");
if( name == null){
response.setContentType("text/html;charset=UTF-8");
response.getWriter().write("未登录, 跳转到登录页面...");
response.setHeader("Refresh", "2;URL=/stuLogin.jsp");
return;
}
%>
<table border="1px" cellspacing="0">
    <thead>
    <th>学生姓名
    </th>
    <th>
        学生年龄
    </th>
    <th>
        学生成绩
    </th>
    </thead>
    <tbody>
        <%
            ArrayList<Student> list =(ArrayList<Student>) session.getAttribute("students");
            for(Student s: list){
        %>
            <tr align="center">
                <td><%=s.getUsername() %></td>
                <td><%=s.getAge() %></td>
                <td><%=s.getChenji() %></td>
            </tr>
        <% } %>
    </tbody>
</table>
</body>
</html>

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

@WebServlet (value = "/loginServlet")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取用户名和密码
        String username = req.getParameter("username");
        String password = req.getParameter("password");

        // 判断用户名是否为空或null,   有效则写入session中
        HttpSession session = req.getSession();

        if( username.equals(null) || "".equals(username)){
            resp.sendRedirect("/stuLogin.jsp");
            return;
        } else  {
            session.setAttribute("username", username);
            resp.sendRedirect("/stuIndex.jsp");
        }

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req, resp);
    }
}

import com.lizicai.bean.Student;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;

@WebServlet (value = "/addStudent")
public class AddStudent extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        HttpSession session = req.getSession();
        Object name = session.getAttribute("username");
        if( name == null){
            resp.setContentType("text/html;charset=UTF-8");
            resp.getWriter().write("未登录, 跳转到登录页面...");
            resp.setHeader("Refresh", "3;URL=/stuLogin.jsp");
            return;
        }

        String username = req.getParameter("username");
        String age = req.getParameter("age");
        String chenji = req.getParameter("chenji");
        Student s = new Student(username, age, chenji);

        String realpath = getServletContext().getRealPath("/stu.txt");
        BufferedWriter bw = new BufferedWriter(new FileWriter(realpath,true));

        bw.write(s.getUsername()+","+s.getAge()+","+s.getChenji());
        bw.newLine();
        bw.close();
        resp.setContentType("text/html;charset=UTF-8");
        resp.getWriter().write("添加成功, 跳转到回添加页面");
        resp.setHeader("Refresh", "3;URL=/addStudent.jsp");

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

import com.lizicai.bean.Student;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.*;
import java.util.ArrayList;

@WebServlet ( value = "/listStudentServlet")
public class ListStudent extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 查询前校验有没有登录
        HttpSession session = req.getSession();
        Object name = session.getAttribute("username");
        if( name == null){
            resp.setContentType("text/html;charset=UTF-8");
            resp.getWriter().write("未登录, 跳转到登录页面...");
            resp.setHeader("Refresh", "3;URL=/stuLogin.jsp");
            return;
        }

        String realPath = getServletContext().getRealPath("/stu.txt");


        ArrayList<Student> list = new ArrayList<>();
        BufferedReader br = new BufferedReader(new FileReader(realPath));
        String line;
        while ( (line = br.readLine()) != null ){
            String[] split = line.split(",");
            Student s = new Student();
            s.setUsername(split[0]);
            s.setAge(split[1]);
            s.setChenji(split[2]);
            list.add(s);
            System.out.println(split[0]+split[1]+split[2]);
        }

        // 集合对象放到会话里
        session.setAttribute("students", list);

        resp.sendRedirect("/listStudent.jsp");

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req, resp);
    }
}

JavaWeb核心二 Li.055

Wed, 29 Sep 2021 00:30:39 +0800

请求对象

返回值 方法名           说明
String getContextPath() 获取虚拟目录名称
String getServletPath() 获取Servlet映射路径
String getRemoteAddr()  获取访问者ip地址
String getQueryString() 获取请求的消息数据
String getRequestURI()  获取统一资源标识符
String getRequestURL()  获取统一资源定位符

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(name = "demo1GetPath", value = "/demo1GetPath")
public class Demo1GetPath extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String contextPath = req.getContextPath();
        System.out.println(contextPath);

        String servletPath = req.getServletPath();
        System.out.println(servletPath);

        String remoteAddr = req.getRemoteAddr();
        System.out.println(remoteAddr);

        String queryString = req.getQueryString();
        System.out.println(queryString);

        String requestURI = req.getRequestURI();
        System.out.println(requestURI);

        StringBuffer requestURL = req.getRequestURL();
        System.out.println(requestURL);
    }
}

请求头信息

返回值              方法名                  说明
String              getHeader(String.name)  根据请求头名获取一个值
Enumeration<String> getHeaders(String.name) 根据请求头名获取多个值
Enumeration<String> getHeaderNames()        获取所有请求头名称

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;

@WebServlet(name = "demo2GetPath", value = "/demo2GetPath")
public class Demo2GetPath extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String host = req.getHeader("Host");
        System.out.println(host);

        Enumeration<String> headers = req.getHeaders("Accept-Encoding");
        System.out.println("----------------------------------------------");
        while (headers.hasMoreElements()){
            String header = headers.nextElement();
            System.out.println(header);
        }
        Enumeration<String> headerNames = req.getHeaderNames();
        System.out.println("================================");
        while (headerNames.hasMoreElements()){
            String headerName = headerNames.nextElement();
            System.out.println(headerName+"...."+ req.getHeader(headerName));
        }
    }
}

获取请求参数信息

返回值               方法名                          说明
String               getParameter(String.name)       根据名称获取数据
String[]             getParameterValues(String.name) 根据名称获取所有数据
Enumeration<String>  getParameterNames()             获取所有名称
Map<String,String[]> getParameterMap()               获取所有参数的键值对

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Map;

@WebServlet(name = "Demo3GetRequestParamter", value = "/demo3GetRequestParamter")
public class Demo3GetRequestParamter extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String name = req.getParameter("username");
        String password = req.getParameter("password");
        System.out.println(name+"..."+password);
        System.out.println("----------------");

        String[] hobbies = req.getParameterValues("hobby");
        for(String hobby:hobbies){
            System.out.println(hobby);
        }
        System.out.println("====================");

        Enumeration<String> parameterNames = req.getParameterNames();
        while (parameterNames.hasMoreElements()){
            String pname = parameterNames.nextElement();
            System.out.println(pname);
        }
        System.out.println("===================");

        Map<String, String[]> parameterMap = req.getParameterMap();
        for(Map.Entry<String,String[]> parameter : parameterMap.entrySet()){
            System.out.print(parameter.getKey());
            for(String s:parameter.getValue()){
                System.out.print(","+s);
            }
            System.out.println();
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

获取请求参数并封装对象

手动封装方式
反射封装方式
工具类封装方式

手动封装的方式

import java.util.Arrays;

public class Student {
    private String username;
    private String password;
    private String[] hobby;
    public Student(){}
    public Student(String username, String password, String[] hobby) {
        this.username = username;
        this.password = password;
        this.hobby = hobby;
    }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public String[] getHobby() { return hobby; }
    public void setHobby(String[] hobby) { this.hobby = hobby; }
    @Override
    public String toString() {
        return "Student{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", hobby=" + Arrays.toString(hobby) +
                '}';
    }
}

import com.bean.Student;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Map;

@WebServlet(name = "demo4GetQequestStudent", value = "/demo4GetQequestStudent")
public class Demo4GetQequestStudent extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String name = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobby = req.getParameterValues("hobby");
        Student student = new Student(name,password,hobby);
        System.out.println(student);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

反射封装方式

import com.bean.Student;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

@WebServlet(name = "demo5GetQequestStudent", value = "/demo5GetQequestStudent")
public class Demo5GetQequestStudent extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Map<String,String[]> map = req.getParameterMap();
        Student stu = new Student();

        for(String name : map.keySet()){
            String[] values = map.get(name);

            try {
                PropertyDescriptor pd = new PropertyDescriptor(name, stu.getClass());
                Method writeMethod = pd.getWriteMethod();
                if( values.length>1){
                    writeMethod.invoke(stu,(Object)values);

                }else{
                    writeMethod.invoke(stu, values);
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println(stu);

    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

工具类封装

在webapp/lib/中添加commons-beanutils-1.9.4.jar和commons-logging-1.2.jar

在本机的tomcat目录中lib目录也要添加上面2个文件

是在我的电脑或者Finder中添加到tomcat目录中lib里上面2个文件

否则提示如下问题

java.lang.NoClassDefFoundError: org/apache/commons/beanutils/BeanUtils
    com.lizicai.servlet.Demo6GetQequestStudent.doGet(Demo6GetQequestStudent.java:25)
    javax.servlet.http.HttpServlet.service(HttpServlet.java:655)
    javax.servlet.http.HttpServlet.service(HttpServlet.java:764)
    org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:53)

import com.bean.Student;
import org.apache.commons.beanutils.BeanUtils;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;

@WebServlet(name = "demo6", value = "/demo6")
public class Demo6GetQequestStudent extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Map<String,String[]> map = req.getParameterMap();
        Student stu = new Student();

        try {
            BeanUtils.populate(stu, map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        System.out.println(stu);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

流对象获取请求信息( 了解即可 )

返回值             方法名         说明
BufferedReader     getReader()    获取字符输入流
ServletInputStream getInputStream 获取字节输入流

** 流对象仅支持Post, 不支持Get**

import com.example.javaweb_test3.HelloServlet;

import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;

@WebServlet(value = "/demo7")
public class Demo7StreamPost extends HelloServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        BufferedReader br = req.getReader();
        String line;
        while (( line = br.readLine()) != null){
            System.out.println(line);
        }

        System.out.println("------------------");
        byte[] arr = new byte[1024];
        int len;
        ServletInputStream sis = req.getInputStream();
        while ( (len = sis.read(arr)) != -1){
            System.out.println(new String(arr,0,len));
        }

    }

    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        super.doGet(request, response);
    }
}

Post 请求中文乱码问题

GET 方式, 没有乱码, 在Tomcat8版本后已经解决
POST 方式, 有乱码问题. 可以通过setCharacterEncoding()方法来解决

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/demo8")
public class Demo8TestUTF8 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        String username = req.getParameter("username");
        System.out.println(username);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req, resp);
    }
}

请求域

请求域(request域) 可以在一次请求范围内进行共享数据.
PC请求 -> ServletA -> ServletB
请求对象操作共享数据方法

返回值 方法名 说明
void setAttribute(String.name,Object.value) 向请求域对象存储数据
Object getAttribute(String.name) 通过名称获取请求域对象的数据
void removeAttribute(String.name) 通过名称移除请求域对象中的数据

请求转发, 客户端的一次请求到达后, 发现需要借助其他Servlet来实现啊啊练车

特点
- 浏览器地址栏不变
- 域对象中的数据不丢失
- 负责转发的Servlet转发前后的响应正文会丢失,(转发的Servelet不能响应)
- 由转发的目的地来响应客户端

返回值           方法名                                            说明
RequestDispacher getRequestDispatcher(String.name)                 获取请求高度对象

void             forward(ServletResquest.req,ServletRestpose.resp) 实现转发

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/demo9")
public class Demo9Froward extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setAttribute("name", "isnewname");

        RequestDispatcher requestDispatcher = req.getRequestDispatcher("/demo10");
        requestDispatcher.forward(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/demo10")
public class Demo10Froward extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Object name = req.getAttribute("name");
        System.out.println(name);

        System.out.println("demo10");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

请求包含

请求包含: 可以合并其他Servlet中的功能一起响应给客户端
特点:
- 浏览器地址栏不变
- 域对象中的数据不丢失
- 被包含的Servlet响应头会丢失,( 转发的Servlet不能响应 )

返回值            方法名                            说明
RequestDispatcher getRequestDispatcher(String.name) 获取请求高度对象
void include(ServletResquest.req,ServletRestpose.resp) 实现包含

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/demo11")
public class Demo11Froward extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setAttribute("name", "isnewname");
        RequestDispatcher requestDispatcher = req.getRequestDispatcher("/demo12");
        requestDispatcher.include(req, resp);
        System.out.println("demo11");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/demo12")
public class Demo12Froward extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Object name = req.getAttribute("name");
        System.out.println(name);

        System.out.println("demo12");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

响应对象

响应: 回馈结果. 在BS架构中, 就是服务器给客户端浏览器反馈结果
响应对象: 就是在项目中用于发送响应的对象.
ServletResponse 和 HttpServletResponse

状态码 说明
200    成功
302    重定向
304    请求资源未改变,使用缓存
400    请求错误,常见于请求参数错误
404    请求资源未找到
405    请求方式不支持
500    服务器错误

返回值              方法名                                    说明
ServletOutputStream getOutputStream()                         获取响应字节输出流对象
void                setContentType("text/html;charset=UTF-8") 设置响应内容类型,解决中文乱码问题

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/responseDemo1")
public class ResponseDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=UTF-8");

        ServletOutputStream sos = resp.getOutputStream();
        String str = "哈哈";
        sos.write(str.getBytes());
    }
}

返回值      方法名                                    说明
PrintWriter getWriter()                               获取响应输入流对象
void        setContentType("text/html;charset=UTF-8") 设置响应内容类型,解决中文乱码

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet(value = "/responseDemo2")
public class ResponseDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=UTF-8");
        String str = "你好";

        PrintWriter pw = resp.getWriter();
        pw.write(str);
    }
}

响应图片

创建字节输入流对象, 关联读取的图片路径
通过响应对象获取字节输出流对象
循环读取和写出图片

图片路径,由相对路径获取到war包的绝对路径,才能访问到

其他资源也是一样的方式

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;

@WebServlet(value = "/responseDemo3")
public class ResponseDemo3 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String realPath = getServletContext().getRealPath("/img/Steve_Halama.jpg");

        System.out.println(realPath);
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream
                (realPath));

        ServletOutputStream outputStream = resp.getOutputStream();
        int len;
        byte[] arr = new byte[8192];
        while ( (len = bis.read(arr)) != -1){
            outputStream.write(arr,0,len);
        }
    }
}

设置缓存

缓存: 对象不经常变化的数据, 我们可以设置合理缓存时间, 以避免浏览器频繁请求服务器. 以此提高效率.

返回值 方法名                               说明
void   setDateHeader(String.name,long.time) 设置消息头添加缓存

Chrome无效

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

@WebServlet(value = "/responseDemo4")
public class ResponseDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        resp.setContentType("text/html;charset=UTF-8");

        resp.setDateHeader("Expires",System.currentTimeMillis()+5*60*1000);
        resp.getWriter().println("缓存");

        System.out.println("请求一次");
    }
}

定时刷新

返回值 方法名 说明
void setHeader(String.name,String.value) 设置消息头定时刷新

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/responseDemo5")
public class ResponseDemo5 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String str = "你的用户名或密码有误, 3秒后自动跳转登录页~";

        resp.setContentType("text/html;charset=UTF-8");
        resp.getWriter().write(str);

        resp.setHeader("Refresh", "3;URL=/stu/login/register.html");

    }
}

请求重定向

请求重定向: 客户端的一次请求到达后, 发现需要借助其他Servlet来实现功能
特点: 浏览器地址栏会发生改变, 两次请求, 请求域对象中不能共享数据, 可以重定向到其他服务器
重写向实现原理
- 设置响应状态码为302 resp.setStatus(302)
- 设置响应的资源路径(响应到哪里去, 通过响应消息头location来指定)resp.setHeader(“location”,"/stu/responseDemo7")

返回值 方法名 说明
void sendRedirect(String.name) 设置重定向

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/responseDemo6")
public class ResponseDemo6 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setAttribute("name","zhangsan");

        resp.sendRedirect(req.getContextPath() +"/responseDemo7");
        resp.sendRedirect("http://baidu.com");
    }
}

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/responseDemo7")
public class ResponseDemo7 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        Object name = req.getAttribute("name");
        System.out.println(name);
    }
}

文件下载

创建字节输入流, 关联文件
设置响应消息头支持的类型
设置响应消息头f以下载方式打开资源
通过响应对象获取字节输出流对象
循环读写
释放资源

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;

@WebServlet( value = "/responseDemo8")
public class ResponseDemo8 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String realPath = getServletContext().getRealPath("/img/Steve_Halama.jpg");

//        Content-Type 消息头名称, 支持的类型
//        application/octet-stream消息头参数 应用类型为字节流
        resp.setHeader("Content-Type", "application/octet-stream");

//        Content-Disposition  消息头名称 处理的形式
//        attachment;filename=Steve_Halama.jpg 消息头参数 附件形式处理 指定下载文件名称
        resp.setHeader("Content-Disposition", "attachment;filename=Steve_Halama.jpg");

        InputStream in = new FileInputStream(realPath);
        BufferedInputStream bis = new BufferedInputStream(in);
        byte[] arr = new byte[10240];
        int len;
        ServletOutputStream sos = resp.getOutputStream();
        while ( (len = bis.read(arr)) != -1){
            sos.write(arr,0,len);
        }

        bis.close();
    }
}

案例学生管理系统

首页, 2个超链接, 添加学生, 查看学生
添加学生, 添加成功后自动跳转到首页
查看学生

<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html>
<head>
    <title>JSP - Hello World</title>
</head>
<body>
<a href="login/addStudent.html">添加学生</a> <a href="/stu/studentList">查看学生</a>
<br/>
<%--<a href="hello-servlet">Hello Servlet</a>--%>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>添加学生</title>
</head>
<body>
<form method="post" action="/stu/studentAdd" autocomplete="off">
  <label for="username">学生姓名:</label>
    <input type="text" name="username" id="username">
    <br/>
    <label for="age">学生年龄:</label>
    <input type="text" name="age" id="age">
    <br/>
    <label for="chenji">学生成绩:</label>
    <input type="text" name="chenji" id="chenji">
    <br/>
    <button type="submit">保存</button>
</form>
</body>
</html>

public class Student {
    private String name;
    private int age;
    private int chenji;
    public Student(){}

    public Student(String name, int age, int chenji) {
        this.name = name;
        this.age = age;
        this.chenji = chenji;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getChenji() {
        return chenji;
    }

    public void setChenji(int chenji) {
        this.chenji = chenji;
    }

    @Override
    public String toString() {
        return
                 name + "," +
                 age +","+
                chenji ;
    }
}

import com.lizicai.bean.Student;

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;

/**
 * 写入学生
 */
@WebServlet(value = "/studentAdd")
public class StudentAdd extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        Student s = new Student();
        s.setName(req.getParameter("username"));
        s.setAge( Integer.parseInt(req.getParameter("age")) ) ;
        s.setChenji(Integer.parseInt(req.getParameter("chenji")));


        String realPath = getServletContext().getRealPath("/img/student.txt");

        Writer out;
        PrintWriter pw = new PrintWriter(new FileWriter(realPath,true));
        pw.println(s);
        pw.close();

        String str = "添加用户成功, 2秒后自动学生添加页~";

        resp.setContentType("text/html;charset=UTF-8");
        resp.getWriter().write(str);

        resp.setHeader("Refresh", "3;URL=/stu/index.jsp");
    }
}

import com.lizicai.bean.Student;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.ArrayList;

/**
 * 查询学生信息
 */

@WebServlet(value = "/studentList")
public class StudentList extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String realPath = getServletContext().getRealPath("/img/student.txt");
        ArrayList<Student> list = new ArrayList<>();
        BufferedReader br = new BufferedReader(new FileReader(realPath));
        String line;
        while ( (line = br.readLine()) != null ){
            String[] split = line.split(",");
            Student s = new Student();
            s.setName(split[0]);
            s.setAge(Integer.parseInt(split[1]));
            s.setChenji(Integer.parseInt(split[2]));
            list.add(s);
        }


        resp.setContentType("text/html;charset=UTF-8");
        PrintWriter pw = resp.getWriter();
        for(Student s : list){
            pw.print(s);
            pw.write("<br/>");
        }
    }
}

JavaWeb核心一 Li.054

Sun, 26 Sep 2021 13:20:52 +0800

1. IDEA 创建 JavaWeb 项目

1.1 选择JavaEE 项目

1.2 Project tempate中选择 Web Application

1.3 一路创建

1.4 在Edit Configurations 设置tomcat, 下面为brew 安装的tomcat地址

/usr/local/Cellar/tomcat@9/9.0.53/libexec

1.5 设置On update action: update resources, On frame deactivation: update resources

1.6 设置第二栏Deployment: Application text: /web_demo

1.7 启动tomcat 即可自动在浏览器上预览

2. 打包JavaWeb 项目

2.1 在本地wepapp文件夹内, 使用jar -cvf myweb.war .打包

jar -cvf myweb.war .

2.2 上传到tomcat服务器中的webapps中, 重启tomcat即可看到发布结果

scp myweb.war webserver:tomcat9.0/webapps/

./shutdown.sh
./startup.sh

3. 更改Tomcat 端口

conf中server.xml 8080更改为80端口

4. 在server.xml中添加其它目录做为tomcat项目

**在Host中间添加

<Context path="/myweb" docBase="/Users/lizicai/IdeaProjects/web_demo/src/main/webapp" />

访问ip:8080/myweb 即可

5. 设置域名访问tomcat

5.1 在server.xml中添加配置

# 在<Engine name="Catalina" defaultHost="localhost"> 下添加
<Host name="tom.lizicai.com" appbase="webapps"
    unpackWARs="true" autoDeploy="true" >
    <Context path="/s" docBase="web_demo" />
</Host>

name 域名
appbase 项目存放路径
unpackWARs 解压
autoDeploy 自动发布

5.2 设置dns, 或者更改本机hosts

# 添加dns
192.168.0.100 tom.lizicai.com

# 更改本机hosts
127.0.0.1 tom.lizicai.com

6. HTTP 协议的响应

常见状态码

200 一切OK
302/307 请求重定向,两次请求,地址栏发生变化
304 请求资源未发生变化,使用缓存
404 请求资源未找到
500 服务器错误

HTTP 响应头

Location               请求重定向的地址,常与302,307配合使用
Server                 服务器相关信息
Content-Type           响应正文的MIME类型
Content-Length         响应正文的长度
Content-Dispositio     告知客户端浏览器,以下载的方式打开响应正文
Refresh                定时刷新
Lash-Modified          服务器资源的最后修改时间
Set-Cookie             会放管理相关,非常重要
Expires:-1             服务器资源到客户端浏览器后的缓存时间
Catch-Control:no-catch 不要缓存

Servlet

Servlet的介绍
- Servlet是运行在Java 服务器端的程序，用于接收和响应来自客户端基于HTTP协议的请求。
- 如果想实现Servlet的功能，可以通过实现javax.servlet.Servlet接口或者继承它的实现类。
- 核心方法：service(),任何客户端的请求都会经过该方法。

对应项目案例在03_JavaWeb

Servlet 的执行流程
- 浏览器地址
- web.xml的地址/url
- /url匹配web.xml的servlet name
- servlet name 匹配servlet class
- 执行servlet calss中的service()方法

实现 GenericServlet

package com.lizicai.test;

import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;

public class Demo1GenericServlet extends GenericServlet {
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("Servlet 执行了");
    }
}

实现HttpServlet

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class Demo2HttpServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("DoPost 执行了");
    }
}

servlet 详细执行过程

Servlet GenericServlet HttpServlet 之间的关系

Servlet 实现方式

第一种
- 实现Servlet接口，实现所有的抽象方法。该方式支持最大程度的自定义。
第二种
- 继承 GenericServlet抽象类，必须重写 service方法，其他方法可选择重写。该方式让我们开发Servlet变得简单。
- 但是这种方式和HTTP协议无关。
第三种
- 继承 Httpser/let抽象类
- 需要重写doGet和doPost方法。该方式表示请求和响应都需要和HTTP协议相关。

Servlet 生命周期

出生: 请求第一次到达Servlet时,对象就创建出来, 并且初始化. 只出生一次, 放到内存中.
活着: 服务器提供服务的整个过程中, 该对象一直存在, 每次都执行service() 方法
死亡: 当前服务停止时, 或者服务器宕机时, 对象死亡.

结论: Servlet 对象只会创建一次, 销毁一次, 所以Servlet对象只有一个实例, 如果对象实例在应用中是唯一存在, 就是单例模式

Servlet 线程案例问题

由于Servlet 采用的单例模式, 也就是整个应用中只有一个实例, 这个实例是否是线程案例的
模拟2个用户同时访问HttpServlet时, doGet中打印用户名, 其中一个sleep3000
结论: 2个用户返回同一个用户名, 线程不安全的.
解决:
- 定义类成员要谨慎. 如果是共用的, 并且只会在初始化时赋值, 其他时间都是获取的话,那没问题的.
- 如果不是共用的, 或者每次使用都有可能对其赋值, 那就要考虑线程安全问题了.
- 变量可以定义到doGet doPost方法内
- 在doGet doPost 使用同步功能, 如 synchronized (this)

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class Demo4HttpServletFixed extends HttpServlet {
    private String username;
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username = null;
        username = req.getParameter("username");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        PrintWriter pw = resp.getWriter();
        pw.println("welcome   "+username);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        synchronized (this){
            username = req.getParameter("username");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            PrintWriter pw = resp.getWriter();
            pw.println("welcome   "+username);
        }

    }
}

Serlet 映射方式

第一种
- 具体名称的方式, 访问的资源路径必须和映射配置安全相同
第二种
- /开头 + 通配符的方式. 只要符合目录结构即可, 不用是考虑结尾
第三种
- 通配符 + 固定格式结尾的方式. 只要符合固定结尾格式即可, 不用考虑前面的路径

**优先级的问题, 越时具体优化级越高, 第一种 > 第二种 > 第三种

<!--    Servlet 映射方式1   -->
    <servlet>
        <servlet-name>demo5HttpServlet</servlet-name>
        <servlet-class>com.lizicai.test.Demo5HttpServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>demo5HttpServlet</servlet-name>
        <url-pattern>/demo5HttpServlet</url-pattern>
    </servlet-mapping>

<!--    Servlet 映射方式2 -->
    <servlet>
        <servlet-name>demo5HttpServlet</servlet-name>
        <servlet-class>com.lizicai.test.Demo5HttpServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>demo5HttpServlet</servlet-name>
        <url-pattern>/demo/*</url-pattern>
    </servlet-mapping>

    <!--    Servlet 映射方式3 -->
    <servlet>
        <servlet-name>demo5HttpServlet</servlet-name>
        <servlet-class>com.lizicai.test.Demo5HttpServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>demo5HttpServlet</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

Servlet 多映射使用的场景

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class Demo6HttpServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        int sum = 100;
        String url = req.getRequestURI();
        String vUrl = url.substring(url.lastIndexOf("/"));
        if( "/vip".equals(vUrl)){
            sum = 95;
        } else if( "/vvip".equals(vUrl)){
            sum = 90;
        } else {
            sum = 100;
        }
        System.out.println(url+"..."+vUrl+"您的商品价格是"+sum+"元");
    }
}

Servlet 创建时机

第一次访问时创建
- 优势: 减少对服务器内存的浪费. 提高了服务器启动的效率
- 弊端: 如果有一些要在应用加载时就做的初始化操作, 无法完成
服务器加载时创建
- 优势: 提前创建好对象, 提高了首次执行的效率. 可以完成一些应用加载时要做的初始化操作
- 弊端: 对服务器内存占用较多, 影响了服务器启动的效率.

**修改Servlet 创建时机, 在标签中, 添加标签 **正整数代表服务器加载时间创建, 值越小优先级越高. 负整数或不写代表第一次访问创建.

<servlet>
    <servlet-name>demo6HttpServlet</servlet-name>
    <servlet-class>com.lizicai.test.Demo6HttpServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>demo6HttpServlet</servlet-name>
    <url-pattern>/demo/*</url-pattern>
</servlet-mapping>

默认Servlet

默认Servlet 是由服务器提供的一个Servlet. 它配置在Tomcat的conf目录中的web.xml中.
它的映射路径是/, 我们在发送请求时, 首先会在我们项目中的web中查看映射配置, 找到则执行.
但是当找不到对应的Servlet路径时, 就去找默认的Servlet, 由默认Servlet处理, 一切都Servlet.

ServletConfig

ServletConfig 是Servlet 的配置参数对象, 在Servlet的规范中, 允许为每一个Servlet都提供一个初始化的配置. 所以每个Servlet都有一个自己的ServletConfig
作用: 在Servlet的初始化时, 把一些配置信息传递给Servlet
生命周期: 和Servlet 相同.

<servlet>
    <servlet-name>demo7ServletConfig</servlet-name>
    <servlet-class>com.lizicai.test.Demo7ServletConfig</servlet-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>demo7ServletConfig</servlet-name>
    <url-pattern>/demo7</url-pattern>
</servlet-mapping>

ServletConfig 常用方法

返回值              方法名                       说明
String              getInitParameter(Stringname) 根据参数名称获取参数值
Enumeration<String> getInitParameterNames()      获取所有参数名称的枚举
String              getServletName()             获取Servlet名称
ServletContext      getServletContext()          获取ServletContext对象

import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;

public class Demo7ServletConfig extends HttpServlet {
    private ServletConfig config;

    @Override
    public void init(ServletConfig config) throws ServletException {
        this.config = config;
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String enCodingValue = config.getInitParameter("encoding");
        System.out.println(enCodingValue);

        Enumeration<String> initParameterNames = this.config.getInitParameterNames();

        while ( initParameterNames.hasMoreElements()){
            String key = initParameterNames.nextElement();
            String value = config.getInitParameter(key);
            System.out.println(key+"...."+value);
        }

        String sereletName = config.getServletName();
        System.out.println(sereletName);

        ServletContext servletContext = config.getServletContext();
        System.out.println(servletContext);
    }
}

ServletContext 介绍

ServletContext 是应用上下文对象(应用域对象). 每一个应用中只有一个SeverContext对象
作用: 可以配置和获得应用的全局初始化参数, 可以实现Servlet之间的数据共享.
生命周期: 应用一加载则创建, 应用被停止则销毁

域对象

域对象指的是对象有作用域. 也就是有作用范围. 域对象可以实现数据的共享. 不同的作用范围的域对象, 共享数据的能力也不一样
在Servlet规范中, 一共有4个域对象. ServletContext就是其中的一个, 它也是Web应用中最大的作用域, 也
叫application域. 它可以实现整个应用之间的数据共享.

<servlet>
    <servlet-name>demo8ServletContext</servlet-name>
    <servlet-class>com.lizicai.test.Demo8ServletContext</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>demo8ServletContext</servlet-name>
    <url-pattern>/demo8ServletContext</url-pattern>
</servlet-mapping>

<context-param>
    <param-name>globalEncoding</param-name>
    <param-value>UTF-8</param-value>
</context-param>
<context-param>
    <param-name>globalDesc</param-name>
    <param-value>ServletContext cc</param-value>
</context-param>

Servlet 常用方法

返回值 方法名                                  说明
String getInitParameter(String.name)           根据名称获取全局配置的参数
String getContextPath()                        获取虚拟路径,这是run配置的delployment的context路径
String getRealPath(String.path)                根据虚拟目录获取应用部署的磁盘绝对路径
void   setAttribute(String.name,Object.object) 向应用域对象中存储数据
Object getAttribute(String.name)               通过名称获取应用域对象中的数据
void   removeAttribute(String.name)            通过名称移除应用域对象中的数据

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class Demo8ServletContext extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();

        String value = servletContext.getInitParameter("globalEncoding");
        System.out.println(value);

        String contextPath = servletContext.getContextPath();
        System.out.println(contextPath);

        String realPath = servletContext.getRealPath("/");
        System.out.println(realPath);

        String realPath2 = servletContext.getRealPath("/b.txt");
        System.out.println(realPath2);
        String realPath3 = servletContext.getRealPath("/WEB-INF/c.txt");
        System.out.println(realPath3);
    }
}

多个Servlet 之间从ServletContext 获取数据

先访问demo8ServletContext2再访问demo8ServletContext3

<!--    多Servlet间共享数据, 通过ServletContext, Demo8ServletContext2和 Demo8ServletContext3之间-->

    <servlet>
        <servlet-name>demo8ServletContext2</servlet-name>
        <servlet-class>com.lizicai.test.Demo8ServletContext2</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>demo8ServletContext2</servlet-name>
        <url-pattern>/demo8ServletContext2</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>demo8ServletContext3</servlet-name>
        <servlet-class>com.lizicai.test.Demo8ServletContext3</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>demo8ServletContext3</servlet-name>
        <url-pattern>/demo8ServletContext3</url-pattern>
    </servlet-mapping>

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class Demo8ServletContext2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        servletContext.setAttribute("name", new String("Zhangsan"));
        System.out.println("访问Demo8ServletContext2...写入Attribute");

    }
}

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class Demo8ServletContext3 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        String value = (String) servletContext.getAttribute("name");
        System.out.println("从ServletContext 取出之前2存入name"+value);
    }
}

注解开发Servlet

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/demo9Servlet")
public class Demo9Servlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("处理请求...");
    }
}

手动创建容器

创建Demo10ManualServle 继承 HttpServlet
MyRegister implements ServletContainerInitializer
在src/main/java文件夹下创建包META-INF.services, 创建文件javax.servlet.ServletContainerInitializer, 添加一行com.lizicai.test.MyRegister
在MyRegister中执行
- Demo10ManualServle demo10ManualServle = new Demo10ManualServle();
- ServletRegistration.Dynamic registration = servletContext.addServlet (“demo10ManualServle”, demo10ManualServle);
- registration.addMapping("/demo10ManualServle");
浏览器访问 /demo10ManualServle

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class Demo10ManualServle extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Demo10ManualServle处理请求...");
    }
}

public class MyRegister implements ServletContainerInitializer {
    @Override
    public void onStartup(Set<Class<?>> set, ServletContext servletContext) throws ServletException {
        // 创建servlet
        Demo10ManualServle demo10ManualServle = new Demo10ManualServle();

        // ServletContext  对象添加Servlet, 并得到Servlet 的动态配置对象
       ServletRegistration.Dynamic registration = servletContext.addServlet
               ("demo10ManualServle", demo10ManualServle);

        registration.addMapping("/demo10ManualServle");

    }
}

com.lizicai.test.MyRegister

案例, 提交学生信息->保存文件中->同时返回一个保存成功信息给浏览器

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;

@WebServlet("/demo11StudentServlet")
public class Demo11StudentServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String name = (req.getParameter("name"));
        String  age =  req.getParameter("age") ;
        String  chenji = req.getParameter("chenji") ;

        File file = new File("/Users/lizicai/workplace/test/b.txt");
        BufferedWriter bw = new BufferedWriter(new FileWriter(file,true));
        String sStr = name+","+age+","+chenji;
        System.out.println(sStr);
        bw.write(sStr);
        bw.close();

        PrintWriter pw2 = resp.getWriter();

        pw2.println("save success");
        pw2.close();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>学生信息保存页</title>
</head>
<body>
  <form action="/stu/demo11StudentServlet" method="get" autocomplete="on">
    <label for="name">学生姓名:</label>
    <input type="text" name="name" id="name">
    <br>
    <label for="age">学生年龄:</label>
    <input type="text" name="age" id="age">
    <br>
    <label for="chenji">学生成绩:</label>
    <input type="text" name="chenji" id="chenji">
    <br>
    <button type="submit">保存信息</button>
  </form>
</body>
</html>

Linux下Java的JDK安装设置和Tomcat安装 Li.053

Sun, 26 Sep 2021 11:31:57 +0800

1. 卸载原有JDK

rpm -qa | grep "java"

yum remove 上面筛选内容

2. 下载JDK8, 解压

进入 官网Java JDK8下载地址

右键选择linux x64 jdk-8u301-linux-x64.tar.gz的下载地址

使用wget下载, 并解压

wget --no-check-certificate --no-cookies --header "Cookie: oraclelicense=accept-securebackup-cookie" https://download.oracle.com/otn/java/jdk/8u301-b09/d3c52aa6bfa54d3ca74e617f18309292/jdk-8u301-linux-x64.tar.gz

tar -zxvf jdk-8u301-linux-x64.tar.gz

3. root用户移动文件, 并设置JAVA_HOME环境变量

3.1 移动文件夹

mv jdk1.8.0_301 /usr/local

3.2 设置JAVA_HOME环境变量

vim /etc/profile 可以对所有用户生效

对当前用户生效则可放在.bashrc中

添加下列信息

export JAVA_HOME=/usr/local/jdk1.8.0_301
export JRE_HOME=${JAVA_HOME}/jre
export CLASSPATH=.:${JAVA_HOME}/lib/dt.JAVA_HOME/lib/tools.jar:${JRE_HOME}/lib
export PATH=${JAVA_HOME}/bin:${PATH}

3.3 重新生效/etc/profile或.bashrc

source /etc/profile

# source ~/.bashrc

3.4 检测Java安装成功

java -version

弹出java的版本, 即是安装成功

4 Tomcat 安装

4.1 Tomcat官网下载

**以Tomcat 9.0 版本为例

wget https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.53/bin/apache-tomcat-9.0.53.tar.gz

4.2 解压

tar -zxvf apache-tomcat-9.0.53.tar.gz

4.3 启动Tomcat, 依赖Java 环境设置

cd apache-tomcat-9.0.53/bin/

./startup.sh

4.4 添加安全组端口, 如腾讯云阿里云

来源      协议端口 策略 备注
0.0.0.0/0 TCP:8080 允许 tomcat

4.5 添加防火墙端口

firewall-cmd --zone=public --add-port=8080/tcp --permanent
firewall-cmd --reload

4.6 浏览器访问 ip:8080

访问http:ip:8080

CSS基础 Li.052

Fri, 24 Sep 2021 17:39:51 +0800

CSS (Cascading Style Sheets) 层叠样式表

选择器: 选择HTML元素的方式, 可以使用标签名, class属性值, id值等多种方式
样式声明: 用于给HTML元素设置具体的样式. 格式是属性名: 属性值.

选择器{
    属性名: 属性值;
    属性名: 属性值;
    属性名: 属性值;
}
h1{
    color: red;
    font-size: 5px;
}

入门案例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>入门案例</title>
    <style>
        h1{
            font-size: 100px;
            color: red;
        }
    </style>
</head>
<body>
<h1 >今天开始爱学习!</h1>
</body>
</html>

CSS 的引用方式

* 内联样式
    在标签中通过style属性来控制样式, 只能影响当前这一行
    格式 <标签 style="属性名:属性值; 属性名:属性值;">内容</标签>
* 内部样式
    在<head>标签中通过<style>标签来控制样式, 只能影响当前文件
    格式<head><style> 选择器{ 属性名:属性值; }</style></head>
* 外部样式
    在<head>标签中通过<link>标签来引入独立css文件, 可以影响不同的文件
    格式<link rel="stylesheet" href="sample.css"> 相对路径css文件或网络css文件都可

CSS 的注释

/* 注释内容 */

CSS 选择器分类
- 基本选择器

元素选择器 标签名 根据标签名匹配元素      div{}
类选择器   .      根据class属性值匹配元素 .center{}
id选择器   #      根据id属性值匹配元素    #username{}

CSS 选择器分类
- 属性选择器

属性选择器 [] 根据指定属性匹配元素 [type]{}[type=text]{}

CSS 选择器分类
- 伪类选择器

标签名:link    未访问的状态   a:link{}
标签名:visited 已访问的状态   a:visited{}
标签名:hover   鼠标悬浮的状态 a:hover{}
标签名:active  已选中的状态   a:active{}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>CSS伪类选择器</title>
    <style>
        a:link{
            color: black;
            text-decoration: none;
        }
        a:visited{
            color: blue;
            text-decoration: none;
        }
        a:hover{
            color: red;
            text-decoration: none;
            font-weight: bold;
        }
        a:active{
            color: yellow;
        }
    </style>
</head>
<body>

<a href="01-入门案例.html" >入门案例</a>
</body>
</html>

CSS 选择器分类
- 组合选择器

后代选择器 空格 使用空格结合多个选择器,基于第一个选择器,匹配第二2选择的所有元素 .center li{}
分组选择器 ,    可能同时匹配多个元素                div,span,p{}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>CSS组合选择器(后台选择器和分组选择器)</title>
    <style>
        .center li{
            color: red;
        }
        div,span,p{
            color: green;
            font-size: 30px;
        }
    </style>
</head>
<body>
<div>asf</div>
<a><span>asdf</span></a>
<p>asdf</p>
<ol class="center" >
    <li>列表</li>
    <li>列表</li>
</ol>
</body>
</html>

边框样式 border

border        设置所有边框
border-top    设置上边框
border-left   设置左边框
border-right  设置右边框
border-bottom 设置下边框
border-radius 设置边框弧度

solid         实线
double        双实线
dotted        圆点
dashed        虚线

文本样式

color           文本颜色     颜色单词(red),RGB(#000000)
font-family     字体         微信雅黑,宋体
font-size       字体大小     像素点20px
text-decoration 文字下划线   none无underline下划线overline上划线line-through
text-align      水平对齐方式 left居左right居右center居中
line-height     行间距       像素点20px
vertical-algn   垂直对齐方式 top居上bottom居下middle居中(还可百分比调节)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>新闻头条</title>
    <link rel="stylesheet" href="news.css">
</head>
<body>

<div class="divTop">
    <a href="#" class="divTopA">登录&nbsp;&nbsp;</a>
    <a href="#" class="divTopA">注册&nbsp;&nbsp;</a>
    <a href="#" class="divTopA">更多&nbsp;&nbsp;&nbsp;</a>
</div>
<div class="divNav">
    <img src="background.png" width="100px" height="40px">
    <a href="#">首页</a><span>&nbsp;/</span>
    <a href="#">科技</a><span>&nbsp;/</span>
    <font color="gray">正文</font>
</div >
<div>
    <hr/>
</div>
<div class="divContend">
    <div class="divLeft">
        <div>
            <a href="#"><img src="test.png"><span>&nbsp;评论</span></a>
        </div>
        <hr/>
        <div>
            <a href="#"><img src="test.png"><span>&nbsp;评论</span></a>
        </div>
        <div>
            <a href="#"><img src="test.png"><span>&nbsp;评论</span></a>
        </div>
        <div>
            <a href="#"><img src="test.png"><span>&nbsp;评论</span></a>
        </div>
    </div>
    <div class="divCenter">
        <p>弹性布局flex是一个几年前的CSS属性了，说它解放了一部分生产力不为过。至少解放了不少CSS布局相关的面试题 :)
            之前网上流行的各种XX布局，什么postion: absolute+margin，float+padding，各种都可以使用flex来取代之。
            早两年在使用的时候，还是会担心有兼容性问题的，某些手机在使用了auto-prefixer以后依然会出现不兼容的问题。
            好在现在已经是2018年了，不必再担心那些老旧的设备，希望这篇文章能帮你加深对flex的认识。
        </p>
        <p>
            首先，flex被称为一个弹性盒模型，也有称弹性布局的。
            总之，盒子也好、布局也罢，我们总是需要有一个容器Container的：
        </p>
        <ol>
            <li>首先，flex被称为一个弹性盒模型，也有称弹性布局的。kskdfjksjdfk</li>
            <li>总之，盒子也好、布局也罢，我们总是需要有一个容器Container的</li>
        </ol>
        <img src="background.png" width="100%">

        <p><strong>加粗1</strong>弹性布局flex是一个几年前的CSS属性了，说它解放了一部分生产力不为过。至少解放了不少CSS布局相关的面试题 :)
            之前网上流行的各种XX布局，什么postion: absolute+margin，float+padding，各种都可以使用flex来取代之。
            早两年在使用的时候，还是会担心有兼容性问题的，某些手机在使用了auto-prefixer以后依然会出现不兼容的问题。
            好在现在已经是2018年了，不必再担心那些老旧的设备，希望这篇文章能帮你加深对flex的认识。
        </p>
        <p><strong>加粗2</strong>弹性布局flex是一个几年前的CSS属性了，说它解放了一部分生产力不为过。至少解放了不少CSS布局相关的面试题 :)
            之前网上流行的各种XX布局，什么postion: absolute+margin，float+padding，各种都可以使用flex来取代之。
            早两年在使用的时候，还是会担心有兼容性问题的，某些手机在使用了auto-prefixer以后依然会出现不兼容的问题。
            好在现在已经是2018年了，不必再担心那些老旧的设备，希望这篇文章能帮你加深对flex的认识。
        </p>
        <img src="background.png" width="100%">
        <p>
            之前网上流行的各种XX布局，什么postion: absolute+margin，float+padding，各种都可以使用flex来取代之。
            早两年在使用的时候，还是会担心有兼容性问题的，某些手机在使用了auto-prefixer以后依然会出现不兼容的问题。
            好在现在已经是2018年了，不必再担心那些老旧的设备，希望这篇文章能帮你加深对flex的认识。
        </p>
    </div >
    <div class="divRight">
        <img src="test.png" width="100%">
        <img src="background.png" width="100%">
        <img src="test.png" width="100%">
        <img src="background.png" width="100%">
    </div>
</div>
<div class="divFooter">
    <a href="#">内容</a>
    <a href="#">内容</a>
    <a href="#">内容</a>
    <a href="#">内容</a>
</div>
</body>
</html>

.divTop{
    background: black;
    height: 50px;
    text-align: right;
    font-size: 25px;
}
.divTop a{
    color: white;
}

.divNav{
    height: 50px;
}

a{
    color: black;
    text-decoration: none;
    font-size: 25px;
}

a:hover{
    color: red;
}

.divContend{
    float: left;
}

.divLeft{
    width: 20%;
    float: left;
    text-align: center;
    vertical-align: 50%;
}

.divLeft img{
    width: 38px;
    height: 38px;
}
.divLeft span{
    vertical-align: 50%;
}

.divCenter{
    width: 60%;
    float: left;
}

.divRight{
    width: 20%;
    float: left;
}


.divFooter{
    clear: both;
    background: blue;
    text-align: center;
}
.divFooter a{
    color: white;
}

.divFooter a:hover{
    color: red;
}

表格标签

table  表格标签           width-宽度height-高度border-边框align-对齐方式
tr     行标签             align-对齐方式
td     单元格标签(列标签) rowspan-合并行colspan-合并列
th     表头标签(加粗和居中)
thread 表头语文标签
tbody  课外书语义标签
tfoot  表脚语义标签

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>表格标签演示</title>
</head>
<body>
<table width="500px" border="1px">
    <thead>
    <tr>
        <th>姓名</th>
        <th>性别</th>
        <th>年龄</th>
        <th>数学</th>
        <th>语文</th>
    </tr>
    </thead>
    <tbody>
    <tr align="center">
        <td>张三</td>
        <td rowspan="2">男</td>
        <td>20</td>
        <td colspan="2">90</td>
        <!--        <td>90</td>-->
    </tr>
    <tr align="center">
        <td>李四</td>
        <!--        <td>男</td>-->
        <td>21</td>
        <td>95</td>
        <td>90</td>
    </tr>
    </tbody>
    <tfoot>
    <tr align="center">
        <td>总分:</td>
        <td colspan="4">365</td>
    </tr>
    </tfoot>
</table>
</body>
</html>

CSS 样式控制

background-repeat 控制背景重复 no-repeat不重复,repeat-x水平重复,repeat-y垂直重复,repeat水平和垂直重复
outline 控制轮廓 double双实线,dotted圆点,dashed虚线,none无
display 控制元素 inline肉联元素(无换行,无长宽),block块级元素(有换行),inline-block肉联元素(有长宽),none隐藏元素

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>背景 轮廓 元素控制</title>
    <style>
        body{
            background: url("bg.png");
            /*background-repeat: no-repeat;*/
            /*background-repeat: repeat-x;*/
            /*background-repeat: repeat-y;*/
            background-repeat: repeat;
        }
        input{
            /*outline: none;*/
            /*outline: none;*/
            outline: double;
        }
        div{
            /*display: none;*/
            /*display: inline;*/
            display: inline-block;
            width: 50px;
        }
    </style>
</head>
<body>
姓名: <input type="text">
<br>
<div>春香</div>
<div>夏香</div>
<div>秋香</div>
<div>冬香</div>
</body>
</html>

CSS 灵魂, 盒子模型

盒子模型是通过设置边框和元素内容的边距, 从而实现布局的方式. 分为内边距和外边距两种方式
如果想实现布局, 可以采用设置内边距或外边距来实现.

内外边距的设置, 取决于所在的视角. 一般常用是外边距. 内边距会导致盒子大小变化

margin-top    上外边距                             margin-top:50px;
margin-left   左外边距                             margin-left:50px;
margin-right  右外边距                             margin-rigth:50px;
margin-bottom 下外边距                             margin-bottom:50px;
margin        通用相同距离                         margin:50px;
margin        单独设置上右下左(从上开始顺时针)边距 margin: 50px 60px 70px 80px;
margin        自动计算外边距并水平居中             margin:auto


padding-top    上外边距                             padding-top:50px;
padding-left   左外边距                             padding-left:50px;
padding-right  右外边距                             padding-rigth:50px;
padding-bottom 下外边距                             padding-bottom:50px;
padding        通用相同距离                         padding:50px;
padding        单独设置上右下左(从上开始顺时针)边距 padding: 50px 60px 70px 80px;
padding        自动计算外边距并水平居中             padding:auto

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录页面</title>
    <link rel="stylesheet" href="login.css">
</head>
<body>
<div>
    <div>
        <img src="bg.png" >
    </div>
    <div class="center">
        <form action="#" method="get" autocomplete="off">
            <table width="100%">
                <thead>
                    <tr>
                        <th colspan="2">账&nbsp;号&nbsp;登&nbsp;录&nbsp;<hr/></th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td> <label for="username">账&nbsp;号&nbsp;</label> </td>
                        <td><input type="text" name="username" id="username" placeholder="请输入账号" required></td>
                    </tr>
                    <tr>
                        <td><label for="password">密&nbsp;码&nbsp;</label></td>
                        <td><input type="password" name="password" id="password" placeholder="请输入密码" required></td>
                    </tr>
                </tbody>
                <tfoot>
                    <tr>
                        <td colspan="2"><button type="submit">确定</button> </td>
                    </tr>
                </tfoot>
            </table>
        </form>
    </div>
    <div class="footer">
        <br/>
        <br/>
        登录/注册即表示您同意&nbsp;&nbsp;
        <a href="#" target="_blank">用户协议</a>&nbsp;&nbsp;
        和
        <a href="#" target="_blank">隐私条款</a>&nbsp;&nbsp;&nbsp;&nbsp;

        <a href="#" target="_blank">忘记密码</a>&nbsp;&nbsp;

    </div>
</div>
</body>
</html>

body{
    background: url("bg2.png");
    background-repeat: no-repeat;
}
.center{
    background: white;
    width: 40%;
    margin: auto;
    margin-top: 100px;
    text-align: center;
    border-radius: 15px;
}
table th{
    color: orangered;
    font-size: 30px;
}

table label{
    font-size: 20px;
}

table input{
    outline: none;
    border-radius: 5px;
    border: 1px solid gray;
    width: 90%;
    height: 40px;
}

table tr{
    line-height: 80px;
}

tfoot button{
    border: 1px solid crimson;
    height: 40px;
    width: 95%;
    border-radius: 5px;
    background: crimson;
    color: white;
    font-size: 20px;
}

.footer{
    width: 35%;
    /*color: gray;*/
    margin: auto;
    font-size: 18px;
}
a{
    font-size: 18px;
    text-decoration: none;

}

Nginx 安装

安装Nginx

编译安装Nginx支持tls1.3

上传则可用scp就可

# 账号密码上传
scp -r folder -P 22 root@10.10.10.10:

# ssh key上传
scp -r folder -P 22 mineFuWuQi:

也可使用rsycn同步图片或其他资源到服务器上

HTML基础 Li.051

Wed, 22 Sep 2021 23:40:44 +0800

html 标签简单介绍

# html5文件声明
<!DOCTYPE html>

# 根标签
<html lang="en">
# 头
<head>
# 字符集
    <meta charset="UTF-8">
# 文档标题, 标签页标题
    <title>01入门案例</title>
</head>

# 身体, 所有文档内容
<body>
<h1 align="center">这是我的第一个HTML入门案例</h1>
</body>
</html>

HTML 注释标签

注释

<!-- 注释 -->

标签

开始和结束标签  <h1></h1>

自闭合标签<br/> <hr/>

标签的嵌套

正确嵌套 <h1><u>sefe</u></h1>
错误嵌套 <h1><u>sefe</h1></u>

块级元素和行内元素

块级元素: 在页面中以块的形式展现, 自己独占一行, 后面内容会自动换行<p><hr><div>
行内元素: 在页面中以行的形式展现, 不会换行<b><i><u><span>

div和span

<div>:  是一个通用的内容容器, 没有特殊语义. 一般用来对其它元素进行分组, 用于样式化相关的需求
<span>: 是一个通用的行内容器, 没有特殊语义. 一般用来纺织元素以达到某种样式.
<div>和<span>标签核心作用是布局页面

HTML 的属性

什么是属性
- 属性可以提供一些额外的信息, 这些信息不会显示在内容中, 但可以改变标签的形式或提供的数据使用
定义格式
- 属性名=属性值
属性的规范
- 同一个标签中属性的名称必须唯一
- 不区分大小写, 推荐小写
- 属性值可以使用单引号或双引号, 推荐双引号
常用的属性
- class 定义元素的类名, 用户选择或访问特定的元素
- id 定义元素的唯一标识, 在整个文档中必须是唯一的
- name 定义元素的名称, 一般用于表单数据提交到服务器
- value 定义在元素内显示的默认值, 一般常用于表单标签中
- style 定义元素的css样式

HTML 的特殊字符

特殊字符

在html中, 像< > " ' 空格 & 都是特殊字符, 它们是语法本身的一部分

字符表示

<    &lt;
>    &gt;
"    &quot;
'    &apos;
&    &amp;
空格 &nbsp;

HTML 练习一

样式演示

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>样式演示</title>
    <style>
        div{
            border: 1px solid red;
            width: 60%;
            height: 500px;
            /* 边框外边距 */
            margin: auto;
        }
    </style>
</head>
<body>
<div>第一个div</div>
</body>
</html>

文本标签

p      表示文件的一个段落
h      表示文档标题,<h1>-<h6>,呈现六个不同级别的标题,h1最高h6最低
hr     表示段落级元素之间的主题转换,一般显示为水平线
ul     表示一个无序列表,可含多个元素,无编号显示
ol     表示一个有序列表,通过渲染为带编号的列表
li     表示列表里的条目
em     表示文本着重,一般用斜体显示
i      表示文本斜体
strong 表示文本重要,一般用粗体显示
b      表示加粗文本
font   表示字体,可以设置样式(已过时)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>新闻标题案例</title>
    <style>
        .divCenter{
            width: 60%;
            margin: auto;
        }
        .headCenter{
            text-align: center;
        }
        p{
            font-size: 18px;
        }
    </style>
</head>
<body>
<div class="divCenter">
    <h1 class="headCenter" >这是一个标题</h1>
</div>
<div class="divCenter">
    <em><font size="2" color="gray">作者: 李小明  2021年10月1日</font></em>
    <hr/>
</div>
<div class="divCenter">
    <h3>弹性布局flex是一个几年前的CSS属性了</h3>
</div>
<div class="divCenter">
    <p>弹性布局flex是一个几年前的CSS属性了，说它解放了一部分生产力不为过。至少解放了不少CSS布局相关的面试题 :)
        之前网上流行的各种XX布局，什么postion: absolute+margin，float+padding，各种都可以使用flex来取代之。
        早两年在使用的时候，还是会担心有兼容性问题的，某些手机在使用了auto-prefixer以后依然会出现不兼容的问题。
    </p>
    <p>
        首先，flex被称为一个弹性盒模型，也有称弹性布局的。
        总之，盒子也好、布局也罢，我们总是需要有一个容器Container的：
    </p>
    <ol>
        <li>首先，flex被称为一个弹性盒模型，也有称弹性布局的。kskdfjksjdfk</li>
        <li>总之，盒子也好、布局也罢，我们总是需要有一个容器Container的</li>
    </ol>

    <p><strong>加粗1</strong>弹性布局flex是一个几年前的CSS属性了，说它解放了一部分生产力不为过。至少解放了不少CSS布局相关的面试题 :)
        之前网上流行的各种XX布局，什么postion: absolute+margin，float+padding，各种都可以使用flex来取代之。
        早两年在使用的时候，还是会担心有兼容性问题的，某些手机在使用了auto-prefixer以后依然会出现不兼容的问题。
    </p>
    <p><strong>加粗2</strong>弹性布局flex是一个几年前的CSS属性了，说它解放了一部分生产力不为过。至少解放了不少CSS布局相关的面试题 :)
        之前网上流行的各种XX布局，什么postion: absolute+margin，float+padding，各种都可以使用flex来取代之。
        早两年在使用的时候，还是会担心有兼容性问题的，某些手机在使用了auto-prefixer以后依然会出现不兼容的问题。
    </p>

</div>
</body>
</html>

案例二头条页

div 样式布局

.left{
width: 20%;
float: left;
}
.center{
width: 59%;
float: left;
}
.right{
width: 20%;
float: left;
}
<div class="left">left</div>
<div class="center">center</div>
<div class="right">right</div>

float 浮动(left right none) clear清除浮动(both) text-align(left  right center) background背景色

图片标签

img    可以显示图片,本地或网络

src    必需,图片地址
title  鼠标悬停(hover)时显示文本
alt    图形不显示时的替换文本
height 图像高度
width  图像宽度

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>图片样式演示</title>
</head>
<body>
<img src="login.png" title="说明" alt="图片不存在" width="1000" height="30px"/>
<img src="no.png" title="说明" alt="图片不存在" width="1000" height="30px"/>
</body>
</html>

超链接标签

a 表示超链接

href                  表示超链接指向的URL 本地或网络都可
targe                 页面打开方式(_self当前页_blank新标签页)
a:hover               鼠标悬停样式
text-decoration:none; 去掉下划线

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>样式演示</title>
    <style>
        div{
            /*border: 1px solid red;*/
        }
        .left{
            width: 20%;
            float: left;
        }
        .center{
            width: 60%;
            float: left;
        }
        .right{
            width: 20%;
            float: left;
        }
        .footer{
            clear: both;
            text-align: center;
            background: blue;
        }
        a{
            color: white;
            text-decoration: none;

        }
    </style>
</head>
<body>
<div><img src="top.png" alt="top.png" width="100%"></div>
<div><img src="navibar.png" alt="navibar.png" width="100%"> </div>
<div>
    <div class="left">
        <img src="left.png" width="100%">
    </div>
    <div class="center">
        <p>弹性布局flex是一个几年前的CSS属性了，说它解放了一部分生产力不为过。至少解放了不少CSS布局相关的面试题 :)
            之前网上流行的各种XX布局，什么postion: absolute+margin，float+padding，各种都可以使用flex来取代之。
            早两年在使用的时候，还是会担心有兼容性问题的，某些手机在使用了auto-prefixer以后依然会出现不兼容的问题。
            好在现在已经是2018年了，不必再担心那些老旧的设备，希望这篇文章能帮你加深对flex的认识。
        </p>
        <p>
            首先，flex被称为一个弹性盒模型，也有称弹性布局的。
            总之，盒子也好、布局也罢，我们总是需要有一个容器Container的：
        </p>
        <ol>
            <li>首先，flex被称为一个弹性盒模型，也有称弹性布局的。kskdfjksjdfk</li>
            <li>总之，盒子也好、布局也罢，我们总是需要有一个容器Container的</li>
        </ol>
        <img src="center1.png" width="100%">

        <p><strong>加粗1</strong>弹性布局flex是一个几年前的CSS属性了，说它解放了一部分生产力不为过。至少解放了不少CSS布局相关的面试题 :)
            之前网上流行的各种XX布局，什么postion: absolute+margin，float+padding，各种都可以使用flex来取代之。
            早两年在使用的时候，还是会担心有兼容性问题的，某些手机在使用了auto-prefixer以后依然会出现不兼容的问题。
            好在现在已经是2018年了，不必再担心那些老旧的设备，希望这篇文章能帮你加深对flex的认识。
        </p>
        <p><strong>加粗2</strong>弹性布局flex是一个几年前的CSS属性了，说它解放了一部分生产力不为过。至少解放了不少CSS布局相关的面试题 :)
            之前网上流行的各种XX布局，什么postion: absolute+margin，float+padding，各种都可以使用flex来取代之。
            早两年在使用的时候，还是会担心有兼容性问题的，某些手机在使用了auto-prefixer以后依然会出现不兼容的问题。
            好在现在已经是2018年了，不必再担心那些老旧的设备，希望这篇文章能帮你加深对flex的认识。
        </p>
        <img src="center2.png" width="100%">
        <p>
            之前网上流行的各种XX布局，什么postion: absolute+margin，float+padding，各种都可以使用flex来取代之。
            早两年在使用的时候，还是会担心有兼容性问题的，某些手机在使用了auto-prefixer以后依然会出现不兼容的问题。
            好在现在已经是2018年了，不必再担心那些老旧的设备，希望这篇文章能帮你加深对flex的认识。
        </p>
    </div>
    <div class="right">
        <img src="right.png" width="100%">
        <img src="right.png" width="100%">
        <img src="right.png" width="100%">
    </div>
</div>

<div class="footer">
    <a href="http://lizicai.com" target="_blank">李子菜</a>
    <a href="http://lizicai.com" target="_blank">李子菜</a>
    <a href="http://lizicai.com" target="_blank">李子菜</a>
    <a href="#" target="_blank">李子菜</a>
</div>
</body>
</html>

案例三注册

div样式布局, 背景图片

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>背景图片演示</title>
    <style>
        body{
            background: url("Halcrow.jpg");
        }
    </style>
</head>
<body>
</body>
</html>

表单标签

form 表单标签

action 用于提交数据的路径
method 用于提交数据的方式( get 和post )
(get 表单数据会显示在地址栏中, 不安全, 地址栏长度有限制)
(post 表单数据不会显示在地址栏中, 数据封装在请求体中, 安全, 长度无限制)
autocomplete 是否记录补全( on 和 off )

表单项标签

lable       表单元素说明,配置表单项标签使用

for         属性值必须和表单项的id属性值一致


input       表单项标签,多种输入类型来接收用户数据

type        数据的类型
id          唯一标识
name        提交服务器的标识
value       默认数据值
placeholder 默认提示信息
required    是否必须有数据


button      按钮标签,不同的按钮有不同的作用

type        属性,按钮的功能(submit,reset,button)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>表单项标签演示</title>
</head>
<body>
<form method="get" action="#" autocomplete="on">
    <label for="username">用户名: </label>
    <input type="text" name="username" id="username" value="" placeholder="请输入用户名" required>
    <button type="submit">提交</button>
    <button type="reset">重置</button>
    <button type="button">普通按钮</button>
</form>
</body>
</html>

表单项标签type属性值

text 普通文本框
password 密码框
email 邮箱框,简单验证
radio 单选框 选择必须有相同的name属性值, value属性设置实际提交的值, checked属性代表默认选中
checkbox 得选框 选项必须有相同的name属性值, value属性设置实际提交的值, checked属性代表默认选中

date           日期框
time           时间框
datetime-local 时间日期框
number         数字框
range          滚动条数值框,min最小值,max最大值,step步进值
search         可清除文本框
tel            电话框
url            网址框
file           文件上传框
hidden         隐藏域 value属性设置实际提交的值

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>表单标签type属性演示</title>
</head>
<body>
<form method="get" action="#">
    <label for="username">用户名:</label>
    <input type="text" name="username" id="username" placeholder="请输入用户名">
    <br/>

    <label for="password">密码:</label>
    <input type="password" name="password" id="password" placeholder="请输入密码" >
    <br/>

    <label for="email">邮箱:</label>
    <input type="email" name="email" id="email" placeholder="请输入邮箱">
    <br/>

    <label for="gender">性别:</label>
    <input type="radio" name="gender" value="male" id="gender">男
    <input type="radio" name="gender" value="female">女
    <input type="radio" name="gender" value="other" checked>保密
    <br/>

    <label for="hobby">爱好:</label>
    <input type="checkbox" name="profession" value="music" id="hobby">音乐
    <input type="checkbox" name="profession" value="game" >游戏
    <br/>

    <label for="birthday">日期:</label>
    <input type="date" name="birthday" id="birthday" >
    <br/>

    <label for="time">时间:</label>
    <input type="time" name="time" id="time" >
    <br/>

    <label for="datetime">日期和时间:</label>
    <input type="datetime-local" name="datetime" id="datetime" >
    <br/>
    <label for="number">number:</label>
    <input type="number" name="number" id="number" >
    <br/>

    <label for="range">rang:</label>
    <input type="range" name="range" id="range" min="0" max="10" step="2">
    <br/>

    <label for="search">search:</label>
    <input type="search" name="search" id="search" >
    <br/>

    <label for="tel">tel:</label>
    <input type="tel" name="tel" id="tel" >
    <br/>

    <label for="url">url:</label>
    <input type="url" name="url" id="url" >
    <br/>

    <label for="file">file:</label>
    <input type="file" name="file" id="file" >
    <br/>

    <input type="hidden" name="hidden" id="hidden" value="see">
    <br/>

    <button name="submit" type="submit" >提交</button>
    <button name="重置" type="reset">重置</button>
</form>
</body>
</html>

其他常用表单项标签

select   表示下拉列表标签
optgroup 不用接列表分组标签 label属性,设置分组名称
option   表示下拉列表项标签
textarea 表示文本域标签     rows属性代表行数,cols属性代表列数

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>其他常用表单项标签演示</title>
</head>
<body>
<form method="get" action="#" autocomplete="off">
    <label for="city">所在城市</label>
    <select name="city" id="city">
        <option>请选择城市</option>
        <optgroup label="直辖市">
            <option>北京</option>
            <option>上海</option>
            <option>深圳</option>
        </optgroup>
        <optgroup label="省会市">
            <option>广州</option>
            <option>杭州</option>
        </optgroup>
    </select>
    <br/>
    个人介绍:
    <textarea name="desc" rows="10" cols="20">
    </textarea>
    <button name="submit" type="submit" >提交</button>
    <button name="重置" type="reset">重置</button>
</form>
</body>
</html>

演示案例三

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>注册页面</title>
    <style>
        body{
            background: url("background.png");
        }
        .divForm{
            background: white;
            width: 400px;
            margin: auto;
            text-align: center;
        }
        .divFormLeft{
            background: white;
            width: 60%;
            margin: auto;
            text-align: left;
        }

    </style>
</head>
<body>
<div>
    <img src="navibar.png" width=100%>
</div>
<div class="divForm">
    <div class="divFormLeft"><a>注册详情</a></div>
    <hr/>
    <div>
        <form method="get" autocomplete="on" action="#">
            <div class="divFormLeft">
                <div >
                    <label for="username">姓名:</label>
                    <input type="text" name="username" id="username" placeholder="在此输入姓名">
                    <br/>
                </div>
                <div>
                    <label for="password">密码:</label>
                    <input type="password" name="password" id="password" placeholder="在此输入密码">
                    <br/>
                </div>
                <div>
                    <label for="email">邮箱:</label>
                    <input type="email" name="email" id="email" placeholder="在此输入邮箱">
                    <br/>
                </div>

                <div>
                    <label for="tel">手机:</label>
                    <input type="tel" name="tel" id="tel" placeholder="在此输入手机">
                    <br/>

                </div>

            </div>
            <hr/>
            <div class="divFormLeft">
                <div >
                    <label for="gender">性别:</label>
                    <input type="radio" name="gender" id="gender" value="male">男&nbsp;
                    <input type="radio" name="gender" value="femal" >女&nbsp;
                    <br/>
                </div>

                <div>
                    <label for="hobby">爱好:</label>
                    <input type="checkbox" name="hobby" id="hobby" value="music">音乐&nbsp;
                    <input type="checkbox" name="hobby" value="movie" >电影&nbsp;
                    <input type="checkbox" name="hobby" value="game" >游戏&nbsp;
                    <br/>
                </div>
                <div>

                    <label for="birthday">出生日期:</label>
                    <input type="date" name="birthday" id="birthday">
                    <br/>
                </div >
                <div>
                    <label >所在城市: </label>
                    <select id="city" name="city">
                        <option>请选择城市</option>
                        <optgroup label="直辖市">
                            <option>北京</option>
                            <option>上海</option>
                            <option>深圳</option>
                        </optgroup>
                        <optgroup label="省会城市">
                            <option>杭州</option>
                            <option>广州</option>
                            <option>南京</option>
                        </optgroup>
                    </select>
                </div>
            </div>
            <hr/>
            <div>
                <label for="sign">个性签名:</label>
                <textarea  name="sign" id="sign" rows="6" cols="30" placeholder="请写出你的与众不同"></textarea>
                <br/>
            </div>
            <div >
                <button type="submit">提交</button>
                <button type="reset">重置</button>
            </div>
            <hr/>
        </form>
    </div>
</div>
</body>
</html>

Linux常用命令与shell语言 Li.050

Tue, 21 Sep 2021 12:58:11 +0800

user 用户相关命令

useradd username

passwd username

usermod -l usernewname username

userdel usernewname

# 强制删除用户usertest主目录和邮件池
userdel -rf usertest

group 用户组相关命令

groupadd groupname

# 查看用户所在的组
groups username

# 更改组名
groupmod -n groupname groupnewname

groupdel groupnewname

管理用户与组

# 往group1中添加用户test
gpasswd -a test group1

# 删除group1中的test
gpasswd -d test group1

# 查看组中有几个用户
cat /etc/group | grep groupname

时间

date

date -d "2021-09-09 12:00:01"

# 修改时间
date -s "2021-09-09 12:00:01"

logname 显示登录用户名

su 切换用户

# 切换到root用户执行命令, 再切换回当前用户, 需要输入root密码
su -c ls root

id 查看用户id 用户组id

top 命令实时监控进程

# 停止监控
q

# 显示完整命令
top -c

# 指定pid
top -p 3550

PS

# 当前正在运行
ps

# 全部运行
ps -A

# 查看更全的信息
ps -ef

# 指定用户进程信息
ps -u username

Kill

# 杀掉进程
kill 999

# 彻底杀掉
kill -9 999

# 杀掉用户进程
kill -9 $(ps -ef | grep username)
killall -u username

shutdown

# 关机
shutdown

# 取消关机
shutdown -c

# 立即关机
shutdown -h now

# 警告 1分钟后关机
shutdown +1 "1分钟关机"

# 警告 1分钟后重启
shutdown -r +1 "1分钟重启"

who 当前登录系统的用户

who

who -H

timedatectl 设置时间

# 查看所有时区
timedatectl list-timezones

# 设置野区
timedatectl set-timezone Asia/Shanghai

# 禁用ntp
timedatectl set-ntp false

# 启用ntp
timedatectl set-ntp true

clear 清屏 command + L 同样能做到

clear

ls

ls

# 显示文件夹(不隐藏的文件与文件夹详细信息)
ls -l

# 全部文件夹与文件(包含隐藏)
ls -a

ls -al

pwd 打印目录

pwd

cd 切换路径

Fasd 跳转比cd更快

# 相对路径
cd testdir

# 绝对
cd /home/test

# 返回上一级
cd ..

# 返回home
cd

# 返回前一个目录
cd -

mkdir 创建文件夹

mkdir folder

# 创建多级目录
mkdir -p test/folder

rmdir 删除空文件夹

rmdir folder

# 删除多级空文件夹
rmdir -p test/test

rm 删除文件或文件夹

rm a.txt

# 删除里面的目录和文件, 可删除多级目录和文件
rm -r test

# 强制删除
rm -f a.txt

cp 文件复制

cp test/a.txt copy.txt

# 复制test文件夹, test文件夹内的文件夹与文件, 全量复制
cp -r test testnew

# 与上面的含义不同, 把test文件夹内的文件夹与文件, 复制到目录testnew下
cp -r test/ testnew

# 复制所有文件

cp * testnew

mv 移动文件夹或文件, 同一目录就有改名的效果

mv test/a.txt testnew

# 改名
mv a.txt aaa.txt

文件drwxr-xr-x

# 第1位
# d 文件夹 - 文件 l链接
# r读 w 写 x可执行

# 第2-4位
# 当前用户的权限

# 第5-7 属组的权限

# 第8-10位 其他组的权限

chgrp (change group)

chgrp root a.txt

# 多了提示语句, 功能和去掉一样
chgrp -v test a.txt

chown (change own) 修改用户和用户组

chown root a.txt

# 目录及内文件夹与文件都修改组
chown -R root folder

# 修改用户与用户组, root(用户):root(用户组)
chown -R root:root folder

chmod 修改权限, 010 权限设置数字二进制,0 则无此权限, 1则有权限, 一个文件有3组这样的

chmod 755 a.xtx

# folder 文件夹内全部文件与文件夹
chmod 755 folder

# u 当前用户, g当前用户组, o其他组
chmod u=rwx,g=rx,o=r a.txt

chmod -R u=rwx,g=rx,o=r folder

# 去掉其他组的权限
chmod -R o-rwx folder

练习java html swift 用户可操作一个文件夹

# 创建用户
useradd java
useradd web
useradd swift

# 创建用户组
groupadd dev

# 用户java web swift添加到用户组dev
gpasswd -a java dev
gpasswd -a web dev
gpasswd -a swift dev

# 创建文件夹
mkdir -p /tmp/work

# 文件夹添加dev组
chgrp -R dev /tmp/work

# 文件夹增加读写执行权限
chmod -R 770 /tmp/work

vim/vi

# 普通模式 -> 退出文件
# :q   退出
# :q!  强制退出
# :wq  保存退出
# :wq! 强制保存退出

# 普通模式->编辑模式
# i 当前字进入编辑模式
# I 在行首进入编辑模式
# a 当前字尾进入编辑模式
# A 行尾进入编辑模式
# o 当前行下一行进入编辑模式
# O 当前行上一行进入编辑模式

# 编辑模式 -> 普通模式
# esc 返回键到普通模式

# 普通模式中, 移动光标
# j 向下一行
# k 向上一行
# h 向前
# l 向后

# 移动指定12行
# 12G

touch 创建文件

# 不存在则创建, 存在则更新修改时间属性
touch a.txt

# 创建a 1-10.xt文件
touch a{1..10}.txt

# 查看文件详细信息
stat a.txt

cat 查看小文件内容(bat 类似软件)

cat a.txt

# 显示行号
cat -n a.txt

less 分屏显示文件内容

less a.txt

# 查看时显示行号
less -N a.txt

# 快捷键同vim

tail 查看文件尾

# 默认展示最后10行
tail a.txt

# 展示3行
tail -3 a.txt

# 动态展示, 会不断刷新
tail -f a.txt

# 5行动态展示
tail -5f a.txt

# 从2行展示到末尾
tail -n+2 a.txt

# 展示最后60字
tail -c 60 a.txt

head 查看文件头, 与tail 一致

grep 搜索文件内容(ag同样也可搜索)

# 查看指定文件的内容
grep "word" a.txt

# 查看指定文件的内容, 并显示行号
grep -n "word" a.txt

# 忽略大小写
grep -i "w" a.txt

# 不包含w则展示这一行
grep -v "w" a.txt

# 与其他命令连用, 查看包含ssh的进程
ps -ef | grep "ssh"

# 查看包含ssh的进程, 不包含本次查询进程
ps -ef | grep ssh | grep -v "grep"

# 查看匹配数量
ps -ef | grep -c ssh

echo

echo "hello"

# 覆盖写入hello 到 a.txt
echo "hello" > a.txt

# 追加写入hello 到 a.txt
echo "hello" >> a.txt

# 把错误或正确的日志追加写入到 error.log中
cat nofile.txt &>> error.log

awk

aa 90 93 90
bb 100 93 90

# 查看包含aa和bb在文件的内容, 不能有空格
cat a.txt | awk '/aa|bb/'

# 空格切割, 再打印出来
# -F ',' 以,切割
# $ + 数字 获取第几段
# $0 获取 当前行
cat a.txt | awk -F ' ' '{print $1,$2,$3,$4}'

# '{OFS="==="}' 代替切割符
cat a.txt | awk -F ' ' '{OFS="==="}{print $1,$2,$3,$4}'

# 制表符 \t 替换切割符
cat a.txt | awk -F ' ' '{OFS="\t"}{print $1,$2,$3,$4}'

# 切割完, 第一段内容转成大写
# toupper() 转成大写
# tolower() 转成小写
# length() 返回字符长度
cat a.txt | awk -F ' ' '{print toupper($1),$2,$3,$4}'

# 'BEGIN{}{totel=totel+$3}END{print totel}'
# 求最后一位合
cat a.txt | awk -F ' ' 'BEGIN{}{totel=totel+$3}END{print totel}'

# 总分和总人数
cat a.txt | awk -F ' ' 'BEGIN{}{totel=totel+$3}END{print totel,NR}'

# 总分和总人数 平均分
cat a.txt | awk -F ' ' 'BEGIN{}{totel=totel+$3}END{print totel,NR,(totel/NR)}'

ln 软链接

# ln -s 源 软链, 源可以是文件和文件夹
ln -s test/a.txt a.txt

ln -s test/folder folder

find 查找文件

find . -name a.c

# 查找修改时间1天内的
find . -ctime -1

find ~ -ctime -1

gzip 压缩

# gzip 压缩, 会删除原文件
gzip a.txt

# 解压-d, 打印过程, 解压同样会删除原压缩文件
gzip -dv a.txt.gz

# 压缩全部文件
gzip *

gunzip

# 解压同样会删除原压缩文件
gunzip a.txt.gz

gunzip *

tar, 本身不具有压缩功能, 只是调用其他压缩软件

# -c 建立新的压缩文件
# -v 显示指令执行过程
# -f <备份文件> 指定压缩文件
# -z 通过gzip处理压缩文件
# -t 列出压缩文件中的内容
# -x 表示解压

# 仅打包文件
tar -cvf a.tar a.txt

# 打包并压缩
tar -zcvf a.gz a.txt

# 仅查看压缩包中内容
tar -ztvf error.gz

# 解压压缩包
tar -zxvf error.gz

zip

# -q 不显示指令执行过程
# -r 递归处理, 指定目录和子目录 子文件一并处理
zip -rq test.zip test

unzip

# -l 显示压缩包中的文件
unzip -l test.zip

# 直接解压
unzip test.zip

# 解压到指定文件夹内
unzip -d ~/dev test.zip

bzip2, 压缩时间长, 压缩率高

bzip2 a.txt

# 打印过程
bunzip2 -v a.txt.bz2

ifconfig

# 查看网卡信息
ifconfig

# 关闭网卡
ifconfig eth0 down

# 启用网卡
ifconfig eth0 up

# 配置ip
ifconfig eth0 192.168.1.200

# 配置ip 和 子网掩码
ifconfig eth0 192.168.1.200 netmask 255.255.255.0

ping

ping 192.168.0.100
ping www.baidu.com

# -c 10 ping 指定10次
ping -c 10 192.168.0.100
ping -c 10 www.baidu.com

netstat 显示网络状况

# 所有的连接情况
netstate -a

# -i 显示网卡列表
netstat -i

lsblk (list block缩写) 列出硬盘使用情况

# 硬盘 硬盘分区信息
lsblk

# 显示详细系统信息
lsblk -f

df 硬盘使用情况

df

# 查看文件硬盘情况
df folder

# 查看所有详细信息
df --total

# -h MB GB KB显示
df -h

mount 挂载

mkdir folder

# 自动挂载
mount -t auto /dev/cdrom folder

# 解除
unmount folder

yum (Yellow dog Updater,Modified)

# 查看可用更新
yum check-update

# 更新所有
yum update

# 安装 更新tree
yum install tree
yum update tree

# 卸载
yum remove tree

# 搜索
yum search tree

# 清除缓存目录下的软件包
yum clean packages

# 清除缓存目录下的headers
yum clean headers

# 清除缓存目录下的旧的headers
yum clean oldheaders

# 清除缓存
yum clean
yum clean all

更改yum源, 或添加其他yum源

yum install wget

cd /etc/yum.repos.d

mv CentOS-BaseOS.repo CentOS-BaseOS.repo-backup

wget -O CentOS-BaseOS.repo http://mirrors.aliyun.com/repo/Centos-7.repo

# 清空之前的缓存
yum clean all

# 使用新的源做缓存
yum makecache

rpm, 安装下载本地并安装, 不常用

shell 命令解释器, bash zsh 多种shell

# 查看默认shell
echo $SHELL

# vim a.sh
# 写入内容

#!/bin/zsh
# 注释
echo "Hello"

# 增加执行权限
chmod 755 a.sh
chmod +x a.sh

# 执行
./a.sh

# 多行注释
:<<! 内容
内容
!

shell 变量

普通变量
- 方式一
  - 变量名=变量值变量值必须是一个整体, 中间没有特殊字符
- 方式二
  - 变量名=‘变量值’ 单引号中的内容, 原样赋值
- 方式三
  - 变量名=“变量值” 如果双引号里面有其他变量, 会把变量的结果进行拼接, 然后赋值

number=10
echo $number
echo ${number}

a='10'
echo $a
echo ${a}
b='$number'
echo $a

c="10"
echo $b
echo ${b}
d="$number"
echo $d

命令变量
- 方式一
  - 变量名=命令
- 方式二
  - 变量名=$(命令)

e=`date`
echo $e

# 推荐方式二
f=$(date)
echo $f

使用变量
- 方式一
  - $变量名非标准
- 方式二 “$变量名” 非标准
- 方式三 ${变量名} 在双号里面使用变量的值
- 方式四 “${变量名}” 标准使用方式

f=$(date)
result="时间${f}"

# 标准使用
echo "${result}"

只读变量

echo "${result}"

readonly result
result="aaa"

删除变量

f=$(date)

echo "${f}"
unset f
echo "${f}"

shell 数组

定义数组, 数组名=(值1 值2…)

arr=(1 2 3 4 5)

给数组的元素赋值, 数组名[索引]=值, bash(0开始) 和 zsh(1开始)的脚标开始位置不一致

arr[1]=10

获取元素, ${数组名[下标]}

${arr[1]}

echo ${arr[1]}

获取长度, ${#数组名[*]} ${#数组名[@]}

${#arr[*]}
${#arr[@]}

echo ${#arr[*]}
echo ${#arr[@]}

shell 算术运算符, 原生bash不支持数学运算

# 格式中有空格, 注意
# +  expr $a + $b
# -  expr $a - $b
# *  expr $a \* $b
# /  expr $a / $b
# %  expr $a % $b
# =  $a = $b
# ++ -- 自增自减 ((a++))


num1=`expr 2 + 2`
echo $num1

num2=`expr 2 \* 2`
echo $num2

a=10
b=20
num3=`expr $a + $b`
echo $num3

c=30
num4="$c"
echo $num4

e=1
((e++))
echo $e

shell 字符串运算符, 1为假 0为真

# 运算符, []之间必须有空格
# =     检测2个字符串是否相等 [ $a = $b ]
# !=    检测2个字符串是否不相等 [ $a != $b ]
# -z    检测字符串长度是否为0 [ -z $a ]
# -n    检测字符串长度是否不为0 [ -n "$a" ]
# $     检测字符串是否为空 [ $a ]

#!/bin/bash
a="aaa"
b="bbb"

[ "${a}" = "${b}" ]
echo $?

[ "${a}" != "${b}" ]
echo $?

[ -z "${a}" ]
echo $?

[ -n "${a}" ]
echo $?

[ $"${a}" ]
echo $?

# 其中$?, 获取上一语句运行结果
# 获取字条串长度
echo ${#a}

shell 关系运算符, 只支持数字, 不支持字符串, 除非字符串是数字

1为假, 0为真

# -eq 检测2个数是否相等 [ $a -eq $b ]
# -ne 检测2个数是否不相等 [ $a -ne $b ]
# -gt 检测左边的数大于右边 [ $a -gt $b ]
# -lt 检测左边的数小于右边 [ $a -lt $b ]
# -ge 检测左边的数是否大于等于右边 [ $a -ge $b ]
# -le 检测左边的数是否小于等于右边 [ $a -le $b ]


#!/bin/bash
a="111"
b="222"

[ "${a}" -eq "${b}" ]
echo $?

[ "${a}" -ne "${b}" ]
echo $?

[ "${a}" -gt "${b}" ]
echo $?

[ "${a}" -lt "${b}" ]
echo $?

[ "${a}" -ge "${b}" ]
echo $?

[ "${a}" -le "${b}" ]
echo $?

shell 布尔运算符

# ! 取反运算 [ ! false ]
# -o 或运行, 有一个表达式为true 则返回true [ $a lt 20 -o $b -gt 100 ]
# -a 与运行, 2个表达式都为true 才返回true [ $a lt 20 -a $b -gt 100 ]

#!/bin/bash
a=111
b=222

[ ! "${a}" -eq "${b}" ]
echo $?

[ "${a}" -gt 100 -o "${a}" -lt 100 ]
echo $?

[ "${a}" -gt 100 -a "${a}" -lt 100 ]
echo $?

[ "${a}" -ge 100 -a "${a}" -le 200 ]
echo $?

shell 逻辑运算符

# 运算符
# && 逻辑的AND [[ true && true ]] 返回true
# || 逻辑OR   [[ false || false ]] 返回false

#!/bin/bash
a=111
b=222

[[ "${a}" -gt 100 && "${a}" -lt 100 ]]
echo $?

[[ "${a}" -gt 100 || "${a}" -lt 100 ]]
echo $?

[[ "${a}" -ge 100 || "${a}" -le 200 ]]
echo $?

shell 判断

# 三种方式
if [ 条件 ]
then
    语句体
if

if [ 条件 ]
then
    语句体
else
    语句体
if

if [ 条件 ]
then
    语句体
elif [ 条件 ]
    语句体
else
    语句体
if


if [ $(ps -ef | grep -c "ssh") -ge 1 ]
then
    echo "true"
fi


if [ $(ps -ef | grep -c "nonono") -gt 2 ]
then
    echo "true"
else
    echo "flase"
fi


if [ $(ps -ef | grep -c "nonono") -gt 2 ]
then
    echo "true"
elif [ $(ps -ef | grep -c "nonono") -eq 1 ]
then
    echo "one"
else
    echo "flase"
fi

shell 选择语句

变量
case 变量 in
模式1 )
    语句体1
    ;;
模式2 )
    语句体2
    ;;
esac

#!/bin/zsh
# 注释
a=2
case "${a}" in
"1" )
    echo '1'
    ;;
"2" )
    echo '1'
    ;;
esac

shell 循环语句

for 变量 in 范围
do
    循环体
done


#!/bin/zsh
# 注释
for loop in 1 2 3 4 5
do
    echo $loop
done


while [ 条件 ]
do
    语句体
done


#!/bin/zsh
# 注释
a=1
while [ "${a}" -le 10 ]
do
    echo "${a}"
    ((a++))
done

shell 函数

函数必须调用

# 无参无返回值
函数名(){
    函数体
}
函数名

#!/bin/zsh
# 注释
printhello(){
    echo "Hello"
}
printhello


# 有参无返回值
函数名(){
    echo $1
    echo $2
}

函数名 a b


printab(){
    echo $1
    echo $2
}

printab 10 20

# 有参有返回值
函数名(){
    echo $1
    return $(($1+$2))
}

函数名 10 20

printhe(){
    echo $1 + $2
    #return `expr $1 + $2` 这样写也可
    return $(($1+$2))
}

printhe 10 20
echo $?

练习

依次输入2个数, 打印合
read 读取屏幕内容

#!/bin/bash
# 注释
getab(){
    echo "第1个数"
    read number1
    echo "第2个数"
    read number2
    return $(($number1+$number2))
}
getab
echo $?

Java的反射 Li.049

Sun, 19 Sep 2021 22:18:30 +0800

反射

反射概述
- Java的反射机制是在运行状态中, 对于任意一个类, 都能知道这个类的所有属性和方法
- 对于任意一个对象, 都能够调用它的任意一个方法和属性
- 这种动态获取信息以及动态调用对象的方法的功能称为Java语文的反射机制
- 想要解剖一个类, 必需先要获取到该类的字节码文件对象
- 而解剖使用的就是Class类中的方法, 所以先要获取到每一个字节码文件对应的Class类型的对象
反射的三种方式
- Object烦的getClass()方法, 判断2个对象是否是同一个字节码文件
- 静态属性class, 锁对象(Person.class)
- Class类中静态方法forName(), 读取配置文件

import com.lizicai.bean.Person;


public class Demo1_Reflect {
    public static void main(String[] args) throws ClassNotFoundException {
        Class clazz1 = Class.forName("com.lizicai.bean.Person");

        Class clazz2 = Person.class;

        Person p = new Person();
        Class clazz3 = p.getClass();

        System.out.println(clazz1 == clazz2);
        System.out.println(clazz2 == clazz3);

    }
}

反射(Class.forName()读取配置文件举例)

import java.io.*;

public class Demo2_Reflect {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
//        nouseReflect();
        String str = null;
        BufferedReader br = new BufferedReader(new FileReader("config.properties"));
        str = br.readLine();
        Class clazz = Class.forName(str);

        Fruit f = (Fruit) clazz.newInstance();
        Juier j = new Juier();
        j.run(f);

    }
    private static void nouseReflect() {
        Juier j = new Juier();
        Apple apple = new Apple();
        j.run(apple);
        j.run(new Orange());
    }
}
interface Fruit{
    public void squeeze();
}
class Apple implements Fruit {
    @Override
    public void squeeze(){
        System.out.println("苹果汁");
    }
}
class Orange implements Fruit{
    @Override
    public void squeeze(){
        System.out.println("橙汁");
    }
}
class Juier{
    public void run(Fruit fruit){
        fruit.squeeze();
    }
    public void run(Orange orange){
        orange.squeeze();
    }
}

com.lizicai.reflect.Orange

通过反射获取带参构造方法并使用

构造函数必须public, 否则报NoSuchMethodException 异常.

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo3_Reflect {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Class clazz = Class.forName("com.lizicai.bean.Person");

//        Person p = (Person) clazz.newInstance();
        Constructor c = clazz.getConstructor(String.class, int.class);
        Person p = (Person) c.newInstance("张三",23);
        System.out.println(p);
    }
}

public class Person {
    private String name;
    private int age;

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }

    @Override
    public int hashCode() {
        return super.hashCode();
    }

    @Override
    public String toString() {
        return this.getName() + this.getAge();
    }
}

通过反射获取成员变量并使用

import com.lizicai.bean.Person;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class Demo4_Reflect {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        Class clazz = Class.forName("com.lizicai.bean.Person");
        Constructor c = clazz.getConstructor(String.class, int.class);
        Person p = (Person) c.newInstance("张三",23);
//        Field f = clazz.getField("name");
        // 暴力反射
        Field f = clazz.getDeclaredField("name");
        // 去除私有权限
        f.setAccessible(true);
        f.set(p,"李四");
        System.out.println(p);
    }
}

通过反射获取方法并使用

import com.lizicai.bean.Person;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo5_Reflect {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, NoSuchFieldException, InvocationTargetException {
        Class clazz = Class.forName("com.lizicai.bean.Person");
        Constructor c = clazz.getConstructor(String.class, int.class);
        Person p = (Person) c.newInstance("张三",23);

        Method m = clazz.getMethod("eat");
        m.invoke(p);

        Method m2 = clazz.getMethod("eat", int.class);
        m2.invoke(p,10);
    }
}

通过反射越过泛型检查

泛型编译时检查, 运行时没有检查

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class Test1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);

        Class clazz = Class.forName("java.util.ArrayList");
        Method m = clazz.getMethod("add",Object.class);
        m.invoke(list,"test");
        System.out.println(list);
    }
}

通过反射写一个通用的设置某个对象的某个属性为指定的值

Person对象仍然是上面的

import java.lang.reflect.Field;

public class Tool {
    public void setProperty(Object obj, String propertyName, Object value) throws NoSuchFieldException, IllegalAccessException {
        Class clazz = obj.getClass();
        Field f = clazz.getDeclaredField(propertyName);
        f.setAccessible(true);
        f.set(obj,value);
    }
}

import com.lizicai.bean.Person;

public class Test2 {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        Person p = new Person("小明",23);
        System.out.println(p);

        Tool t = new Tool();
        t.setProperty(p,"name","小红");
        System.out.println(p);
    }
}

练习

import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Test3 {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InvocationTargetException, IllegalAccessException, NoSuchMethodException, InstantiationException {

        File file = new File("demo.properties");
        BufferedReader br = new BufferedReader(new FileReader(file));
        String clazzName = br.readLine();
        br.close();

        Class clazz = Class.forName(clazzName);

        DemoClass dc = (DemoClass) clazz.newInstance();

        Method m = clazz.getMethod("run");
        m.invoke(dc);
    }
}

public class DemoClass {
    public void run(){
        System.out.println("大王叫我来巡山");
    }
}

com.lizicai.test.DemoClass

动态代理的概述和实现

写好了代理, 就能在所有类前后进行一些处理

public interface User {
    public void add();
    public void delete();
}

public class UserImp implements User{
    @Override
    public void add() {
//        System.out.println("权限校验");
        System.out.println("添加");
//        System.out.println("日志记录");
    }

    @Override
    public void delete() {
//        System.out.println("权限校验");
        System.out.println("删除");
//        System.out.println("日志记录");
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {
    private Object target;
    public MyInvocationHandler(Object target){
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("权限检验");
        method.invoke(target,args);
        System.out.println("日志记录");
        return null;
    }
}

import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args) {
        User ui = new UserImp();
        ui.add();
        ui.delete();
        MyInvocationHandler m = new MyInvocationHandler(ui);
        User u = (User) Proxy.newProxyInstance(ui.getClass().getClassLoader(), ui.getClass().getInterfaces(),m);

        u.add();
        u.delete();
    }
}

模版(Template)设计模式概述和使用

模版设计模式概述
- 模版方法模式就是定义一个算法模版, 而将具体的算法延迟到子类中实现
优点缺点
- 使用模版方法模式, 在定义骨架的同时, 可以很灵活实现具体的方法, 满足用户灵活多变的需求
- 如果算法有修改, 则需要修改抽象类

public class Demo1_Template extends TestTime{
    public static void main(String[] args) {
        Demo1_Template d = new Demo1_Template();
        System.out.println(d.getTime());
    }
    @Override
    public void code() {
        for(int i=0;i<100000;i++){
            System.out.println(i);
        }
    }
}

abstract class TestTime{
    final public long getTime(){
        long start = System.currentTimeMillis();
        code();
        long end = System.currentTimeMillis();
        return end - start;
    }
    public abstract void code();
}

自己实现枚举类

概述
- 是指将变量的值一一列举出来, 变量的值仅限于列举出来的值的范围内
单例模式, 只有一个实例
- 多例类就是一个类有多个实例, 但不是无限多个实例, 是有限个数的实例, 这才是枚举类.
枚举类有下例3种形式

public class Week {
    final static Week MON = new Week();
    final static Week TUE = new Week();
    final static Week WED = new Week();
    private Week(){}
}

public class Week2 {
    final static Week2 MON = new Week2("星期一");
    final static Week2 TUE = new Week2("星期二");
    final static Week2 WED = new Week2("星期三");
    String name;
    private Week2(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name;
    }
}

public abstract class Week3 {
    final static Week3 MON = new Week3("星期一"){
        @Override
        public void show() {
            System.out.println("星期一");
        }
    };
    final static Week3 TUE = new Week3("星期二"){
        @Override
        public void show() {
            System.out.println("星期二");
        }
    };
    final static Week3 WED = new Week3("星期三") {
        @Override
        public void show() {
            System.out.println("星期三");
        }
    };
    String name;
    private Week3(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name;
    }

    public abstract void show();
}

public class Demo1_Enum {
    public static void main(String[] args) {
        Week mon = Week.MON;
        System.out.println(mon);


        Week2 Mon = Week2.MON;
        Week2 Tue = Week2.TUE;
        Week2 Wed = Week2.WED;
        System.out.println(Mon);
        System.out.println(Tue);
        System.out.println(Wed);

        Week3 MON = Week3.MON;
        Week3 TUE = Week3.TUE;
        Week3 WED = Week3.WED;
        MON.show();
        TUE.show();
        WED.show();
    }
}

通过enum实现枚举类

public enum Week {
    MON,TUE,WED;
}

public enum Week2 {
    MON("星期一"),TUE("星期二"),WED("星期三");
    private String name ;
    Week2(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public enum Week3 {
    MON("星期一"){
        @Override
        public void show() {
            System.out.println("星期一");
        }
    },TUE("星期二"){
        @Override
        public void show() {
            System.out.println("星期二");
        }
    },WED("星期三"){
        @Override
        public void show() {
            System.out.println("星期三");
        }
    };
    private String name ;
    Week3(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }
    public abstract void show();
}

public class Demo1_Enum {
    public static void main(String[] args) {
        Week mon = Week.MON;
        Week tue = Week.TUE;
        System.out.println(mon);
        System.out.println(tue);

        Week2 Mon = Week2.MON;
        Week2 Tue = Week2.TUE;
        System.out.println(Mon);
        System.out.println(Tue.getName());

        Week3 MON = Week3.MON;
        Week3 TUE = Week3.TUE;
        Week3 WED = Week3.WED;
        System.out.println(MON);
        System.out.println(TUE.getName());
        System.out.println(WED.getName());
    }
}

switch 使用枚举

public static void demo1(){
    Week2 MON = Week2.TUE;
    switch (MON){
        case MON:
            System.out.println("星期一");
            break;
        case TUE:
            System.out.println("星期二");
            break;
        case WED:
            System.out.println("星期三");
            break;
    }
}

常用的枚举方法

public final int ordinal() 获取枚举的位置
public final int compareTo(E o) 比较枚举位置, 返回差
public final String name() 获取枚举实例的名字
public static <T extends Enum> T valueOf(Class enumType, String name) 字节码对象获取枚举项
values 获取枚举的数组

public class Demo2_Enum {
    public static void main(String[] args) {
        Week2 mon = Week2.MON;
        Week2 tue = Week2.TUE;
        Week2 wed = Week2.WED;

        System.out.println(mon.ordinal());
        System.out.println(tue.ordinal());
        System.out.println(wed.ordinal());

        System.out.println(mon.compareTo(tue));
        System.out.println(mon.compareTo(wed));

        System.out.println(mon.name());
        System.out.println(tue.name());

        System.out.println(mon);
        System.out.println(tue.toString());
        // 字节码对象获取枚举项
        Week2 TUE = Week2.valueOf(Week2.class,"TUE");
        System.out.println(TUE);

        Week2[] arr = Week2.values();
        for(Week2 w:arr){
            System.out.println(w);
        }
    }
}

JDK 1.7 新增内容

switch支持字符串
异常catch多个异常, 用|隔开
try-whith-resources 自动关流

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo3_AutoClose {
    public static void main(String[] args) {
    File file = new File("config.properties");
    //资源放在try()中, 会自动关闭资源, 不用在finally 中关闭了
        try ( FileInputStream fis = new FileInputStream(file)){
            int b;
            while ( ( b = fis.read() ) != -1){
                System.out.println(b);
            }
        } catch (IOException e){
            System.out.println(e.getMessage());
        }
    }
}

JDK 1.8 新增内容

接口可以支持default修饰, 有方法体
接口也可以有静态方法了
内部类可访问的变量默认是final修饰

public class Demo4_JKD18 {
    // JDK1.8新特性
    public static void main(String[] args) {
        Demo d = new Demo();
        d.show();
        Inter.test();

        d.run();
    }
}

interface Inter{
    public default void show(){
        System.out.println("显示");
    }

    public static void test(){
        System.out.println("测试");
    }
}
class Demo implements Inter{

    public void run(){
        // num 默认是final
        int num = 20;
        class Inner{
            public void fun(){
                System.out.println("fun");
            }
        }
        Inner i = new Inner();
        i.fun();
    }
}

Java的网络编程 Li.048

Fri, 17 Sep 2021 10:27:11 +0800

网络通信

ip 电脑地址
UDP TCP
端口号
socket 插座, 数据流间的插座, 用来联通
类似电脑是港口ip, socket是航线用来发货, 端口号是港口停放船的泊位, UDP TCP是小船还是大船来运送数据箱子

DatagramSocket 与 DatagramPacket

DatagramSocket 创建一条航线
DatagramPacket 指定电脑ip(港口), 端口号(泊位), 运送的数据(集装箱)

import java.io.IOException;
import java.net.*;
import java.nio.charset.StandardCharsets;

public class Demo1_Send {
    public static void main(String[] args) throws IOException {
        String msg = "中午一起吃饭";
        DatagramSocket datagramSocket = new DatagramSocket();
        DatagramPacket datagramPacket = new DatagramPacket
                (msg.getBytes(StandardCharsets.UTF_8),msg.getBytes().length, InetAddress.getByName("127.0.0.1"),2000);

        datagramSocket.send(datagramPacket);
        datagramSocket.close();
    }
}

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class Demo2_Receive {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(2000);
        DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
        socket.receive(packet);
        byte[] arr = packet.getData();
        int len = packet.getLength();
        System.out.println(new String(arr,0,len));
        socket.close();
    }
}

能够不断录入的版本

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class Demo3_Send {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        DatagramSocket datagramSocket = new DatagramSocket();
        while (true){
            String msgLine = sc.nextLine();
            if( "quit".equals(msgLine)){
                break;
            }
            System.out.println(msgLine);
            DatagramPacket packet =
                    new DatagramPacket (msgLine.getBytes(StandardCharsets.UTF_8),
                            msgLine.getBytes().length,
                            InetAddress.getByName("127.0.0.1"),
                            2000);

            datagramSocket.send(packet);
        }
        datagramSocket.close();
    }
}

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class Demo3_Receive {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(2000);
        DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);

        while (true){
            socket.receive(packet);
            byte[] arr = packet.getData();
            int len = packet.getLength();
            System.out.println("信息" + new String(arr,0,len));
        }
    }
}

多线程发送和接收信息

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class Demo4_MoreThread {
    public static void main(String[] args) {
        MyReceive myReceive = new MyReceive();
        MySend mySend = new MySend();
        myReceive.start();
        mySend.start();
    }

}
class MyReceive extends Thread{
    @Override
    public void run() {
        try {
            DatagramSocket socket = null;
            socket = new DatagramSocket(2000);
            DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);

            while (true){
                socket.receive(packet);
                byte[] arr = packet.getData();
                int len = packet.getLength();
                System.out.println("信息" + new String(arr,0,len));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class MySend extends Thread{
    @Override
    public void run() {
        Scanner sc = new Scanner(System.in);
        DatagramSocket datagramSocket = null;
        try {
            datagramSocket = new DatagramSocket();
            while (true){
                String msgLine = sc.nextLine();
                if( "quit".equals(msgLine)){
                    break;
                }
                DatagramPacket packet =
                        new DatagramPacket (msgLine.getBytes(StandardCharsets.UTF_8),
                                msgLine.getBytes().length,
                                InetAddress.getByName("127.0.0.1"),
                                2000);

                datagramSocket.send(packet);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        datagramSocket.close();
    }
}

GUI 聊天

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo5_GUIChat extends Frame{
    private TextField textField;
    private TextArea viewText;
    private TextArea sendText;
    private Button send;
    private Button log;
    private Button clear;
    private Button shake;
    private DatagramSocket socket;
//    private BufferedReader br;
    private FileInputStream fis;
    private BufferedWriter bw;
    public Demo5_GUIChat() throws SocketException,IOException{
        init();
        southPanel();
        centerPanel();
        event();
        Receive r = new Receive();
        r.start();
        this.setVisible(true);

    }

    public void event() {
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                try {
                    bw.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
                socket.close();
                System.exit(0);
            }
        });
        send.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    send();
                } catch (SocketException ex) {
                    ex.printStackTrace();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        });
        log.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    logFile();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        });

        clear.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                viewText.setText("");
            }
        });

        shake.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
//                shake();
                try {
                    send(new byte[]{-1},textField.getText());
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        });

        sendText.addKeyListener(new KeyAdapter() {
            @Override
            public void keyReleased(KeyEvent e) {
                if(e.getKeyCode() == KeyEvent.VK_ENTER ){
                    try {
                        send();
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                }
            }
        });
    }
    public void shake(){
        int x = this.getX();
        int y = this.getY();
        for(int i=0;i<20;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(i % 2 == 0){
                this.setLocation(x+3,y+3);
            } else {
                this.setLocation(x,y);
            }
        }
    }
    public void logFile() throws IOException {

//        br = new BufferedReader(new InputStreamReader(new FileInputStream("chat.log")));
//        br = new BufferedReader(new FileReader("chat.log"));
//        viewText.setText("");
//        int len ;
//        char [] arr = new char[1024];
//        while ( ( len =br.read(arr)) != -1){
//            viewText.append(new String(arr,0,len));
//        }
//        br.close();
        fis = new FileInputStream("chat.log");
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        int len;
        byte[] arr = new byte[8192];
        while ( (len = fis.read(arr)) != -1){
            bos.write(arr,0,len);
        }
        viewText.setText(bos.toString());
        bos.close();

    }
    public void send(byte[] arr,String ip) throws IOException {
        DatagramPacket packet = new DatagramPacket(arr,
                arr.length,
                InetAddress.getByName(ip),
                9999);
        socket.send(packet);
    }

    public void send() throws IOException {
        String msg = sendText.getText();
        if( "".equals(msg.trim())  || null ==msg){
            return;
        } else {
            String ip = textField.getText();
            if( ip.equals(null) || ip.trim().equals("")){
                ip = "255.255.255.255";
            }
            String time = getTime();
            send(msg.getBytes(StandardCharsets.UTF_8),ip);

            String chatlog = time+" "+"我对:"+(ip.equals("255.255.255.255")? "所有人":ip)+"说:"+"\n"+ msg +"\n"+"\n";
            viewText.append(chatlog);
            bw.write(chatlog);
            bw.flush();
            sendText.setText("");
        }

    }
    public String getTime(){
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        return sdf.format(date);
    }


    public void centerPanel() {
        Panel center = new Panel();
        viewText = new TextArea();
        sendText = new TextArea(5,2);
        viewText.setEditable(false);
        viewText.setBackground(Color.WHITE);
        center.setLayout( new BorderLayout());
        center.add(sendText, BorderLayout.SOUTH);
        center.add(viewText, BorderLayout.CENTER);
        sendText.setFont(new Font("xxx", Font.PLAIN,20));
        viewText.setFont(new Font("xxx", Font.PLAIN,16));
        this.add(center, BorderLayout.CENTER);
    }

    public void southPanel() {
        Panel south = new Panel();
        textField = new TextField(15);
        textField.setText("127.0.0.1");
        send = new Button("发送");
        log = new Button("记录");
        clear = new Button("清除");
        shake = new Button("振动");
        south.add(textField);
        south.add(send);
        south.add(log);
        south.add(clear);
        south.add(shake);
        this.add(south, BorderLayout.SOUTH);
    }

    private void init() throws IOException {
        this.setLocation(500,10);
        this.setSize(500,800);
        socket = new DatagramSocket();
//        bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("chat.log",true)));
        bw = new BufferedWriter(new FileWriter("chat.log",true));
    }

    public static void main(String[] args) throws SocketException,IOException {
        Demo5_GUIChat guiChat = new Demo5_GUIChat();

    }
    private class Receive extends Thread{
        //发送 接收同时进行
        @Override
        public void run() {
            try {
                DatagramSocket socket = new DatagramSocket(9999);
                DatagramPacket packet = new DatagramPacket(new byte[8192], 8192);
                while (true){
                    socket.receive(packet);
                    byte[] arr = packet.getData();
                    int length = packet.getLength();
                    if( length == 1 && arr[0] == -1){
                        shake();
                        continue;
                    }
                    String msg = new String(packet.getData(), 0, packet.getLength());
                    String chatlog = getTime()+" "+textField.getText()+" "+"对我说:"+"\n"+msg+"\n\n" ;
                    viewText.append(chatlog);
                    bw.write(chatlog);
                    bw.flush();
                }
            } catch (SocketException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

TCP协议 (重要)

TCP 三次握手

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class Demo2_Server {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(2000);
        Socket socket = server.accept();

        InputStream is = socket.getInputStream();
        OutputStream os = socket.getOutputStream();

        os.write("明天还上班不".getBytes(StandardCharsets.UTF_8));

        byte[] arr = new byte[8192];
        int len;
        len = is.read(arr);
        System.out.println(new String(arr,0,len));
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class Demo1_Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.01",2000);
        InputStream is = socket.getInputStream();
        OutputStream os = socket.getOutputStream();
        byte[] arr = new byte[8192];
        int len = is.read(arr);

        os.write("吃了".getBytes(StandardCharsets.UTF_8));
        System.out.println(new String(arr,0,len));
    }
}

服务端客户端TCP 优化

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class Demo2_Server {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(2000);
        Socket socket = server.accept();

        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        OutputStream out;
        PrintStream ps = new PrintStream(socket.getOutputStream()) ;
        ps.println("快乐, 放假了");
        System.out.println(br.readLine());
        ps.println("出来玩吧");
        System.out.println(br.readLine());
    }
}

import java.io.*;
import java.net.Socket;

public class Demo2_Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.01",2000);
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintStream ps = new PrintStream(socket.getOutputStream()) ;

        System.out.println( br.readLine());
        ps.println("是的, 放假了");
        System.out.println( br.readLine());
        ps.println("起飞");
    }
}

服务增加多线程

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Demo2_Server {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(2000);
        while (true){
            final Socket socket = server.accept();
            new Thread(){
                @Override
                public void run() {
                    try {
                        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        OutputStream out;
                        PrintStream ps = new PrintStream(socket.getOutputStream()) ;
                        ps.println("快乐, 放假了");
                        System.out.println(br.readLine());
                        ps.println("出来玩吧");
                        System.out.println(br.readLine());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }.start();
        }
    }
}

服务端反转字符并写给客户端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Demo3_Server {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(2000);
        while (true){
            final Socket socket = server.accept();
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        try {
                            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                            PrintStream ps = new PrintStream(socket.getOutputStream()) ;
                            StringBuilder sb = new StringBuilder( br.readLine());
                            ps.println(sb.reverse());
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }.start();
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class Demo3_Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.01",2000);
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintStream ps = new PrintStream(socket.getOutputStream()) ;

        Scanner sc = new Scanner(System.in);
        String s = null;
        while (true){
            s = sc.nextLine();
            ps.println(s);
            System.out.println( br.readLine());
        }
    }
}

上传文件到服务端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Demo4_Server_SaveFiles {
    public static void main(String[] args) throws IOException{
        ServerSocket server = new ServerSocket(2000);
        while (true){
            final Socket socket = server.accept();
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        try {
                            InputStream is = socket.getInputStream();
                            BufferedReader br = new BufferedReader(new InputStreamReader(is));
                            PrintStream ps = new PrintStream(socket.getOutputStream()) ;


                            File dir = new File("update");
                            if(!dir.exists()){
                                dir.mkdir();
                            }
                            String fileName = br.readLine();
                            System.out.println(fileName);
                            File file = new File(dir, fileName);
                            if( file.exists()){
                                ps.println("已存在");
                                return;
                            }else {
                                ps.println("不存在");
                            }

                            byte[] arr = new byte[8192];
                            int len;
                            FileOutputStream fos = new FileOutputStream(file);
                            while ( ( len = is.read(arr)) != -1){
                                fos.write(arr,0,len);
                            }
                            fos.close();
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }.start();
        }
    }
}

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class Demo4_Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.01",2000);
        InputStream is = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        PrintStream ps = new PrintStream(socket.getOutputStream()) ;

        Scanner sc = new Scanner(System.in);
        String s = null;
        int len;
        byte[] arr = new byte[8192];
        while (true){
            s = sc.nextLine();

            File file = new File(s);
            if( !file.exists()){
                System.out.println("文件不存在");
            } else if( file.isDirectory()){
                System.out.println("文件夹, 请重新输入文件");
            } else if (file.isFile()){
                ps.println(s);
                String flag = br.readLine();
                if( "已存在".equals(flag)){
                    System.out.println(flag);
                    return;
                } else {
                    InputStream inputStream = new FileInputStream(file);
                    while ( (len = inputStream.read(arr)) != -1){
                        ps.write(arr,0,len);
                    }
                    ps.flush();
                }
            }
        }
    }
}

Java的多线程二 Li.047

Sun, 12 Sep 2021 22:36:28 +0800

单例设计模式(重要)

保证类在内存中只有一个对象
饿汉式, 空间换时间, 类创建的时候就创建对象, 线程安全的
懒汉式, 双叫单例加载模式, 使用的时候才创建对象, 存在线程安全问题
区别, 饿汉式空间换时间, 懒汉式时间换空间, 多线程访问时, 饿汉式不会创建多个对象, 懒汉式可能创建多个对象

public class Demo1_Singleton {

    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();

        Singleton s2 = Singleton.getInstance();

        System.out.println(s1);
        System.out.println(s2 == s1);
    }
}

class Singleton{
    // 1. 私有化构造函数, 就不能随意实例类了
    private Singleton (){}

    // 2. 创建实例
    private static Singleton s = new Singleton();



    // 3. 饿汉式
    public static Singleton getInstance() {
        return s;
    }

}

class SingletonLazy{
    private SingletonLazy (){}

    private static SingletonLazy s ;

    public static SingletonLazy getInstance() {
        if(s == null){
            s = new SingletonLazy();
        }
        return s;
    }
}

class SingletonFinal{
    private SingletonFinal(){}
    public static final SingletonFinal s = new SingletonFinal();
}

Runtime 类

Process exec(String command) throws IOException 执行命令

import java.io.IOException;

public class Demo2_Runtime {
    public static void main(String[] args) throws IOException {
        Runtime runtime = Runtime.getRuntime();
        runtime.exec("ls");
    }
}

Timer ( 可以被ScheduledExecutorService取代 )

一种工具, 线程用其安排以后在后台线程中执行的任务, 可安排任务执行一次, 或者定期重复执行

private static void demo1() {
    Timer t = new Timer();
//  t.schedule(new MyTimerTask(), new Date(121,8,13,11,8,01);  // 定时 执行
    // 循环执行, 每3秒执行一次
    t.schedule(new MyTimerTask(), new Date(121,8,13,11,8,01),3000);
    while (true){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(new Date());
    }
}

ScheduledExecutorService

Time的缺陷, 单线程多个任务排队, 一个任务执行时间长了, 后面任务受影响, 一个任务挂了, 后面的任务无法执行, 强依赖系统时间, 系统时间更改则会更改
ScheduledExecutorService 多线程, 则没有上述问题
ScheduledFuture scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) 延时initialDelay, 开始周期delay执行

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Demo3_Timer {
    public static void main(String[] args) throws InterruptedException {
        // 一个任务出现 异常, 不影响其他任务
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(2);
        ses.scheduleAtFixedRate(
                new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("===" + Thread.currentThread().getName() + "===");
                    }
                }
                , 0, 3, TimeUnit.SECONDS);


        ses.scheduleAtFixedRate(
                new Runnable() {
                    @Override
                    public void run() {
                        int i = 1/0;
                        System.out.println("***" + Thread.currentThread().getName() + "***");
                    }
                }
                , 0, 3, TimeUnit.SECONDS);

    }
    private static void demo2(){
        // 一个任务执行时间长了, 也不会任务其他任务
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(2);
        ses.scheduleAtFixedRate(
                new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("===" + Thread.currentThread().getName() + "===");
                        try {
                            TimeUnit.SECONDS.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                , 0, 3, TimeUnit.SECONDS);


        ses.scheduleAtFixedRate(
                new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("***" + Thread.currentThread().getName() + "***");
                    }
                }
                , 0, 3, TimeUnit.SECONDS);
    }

    private static void demo1() {
        Timer t = new Timer();
//        t.schedule(new MyTimerTask(), new Date(121,8,13,11,8,01);  // 定时 执行
        // 循环执行, 每3秒执行一次
        t.schedule(new MyTimerTask(), new Date(121,8,13,11,8,01),3000);
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(new Date());
        }
    }
}
class MyTimerTask extends TimerTask{
    @Override
    public void run() {
        System.out.println("起来上班");
    }
}

多个线程的通信(重要)

this.notify() 随机唤醒单个等待线程

public class Demo1_Notify {
    public static void main(String[] args) {
        Printer p = new Printer();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                        p.method1();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                        p.method2();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }
}

class Printer{
    private int flag = 1;
    public void method1() throws InterruptedException {
        synchronized (this){
            if(flag != 1){
                this.wait();
            }
            System.out.println("aaaa");
            flag = 2;
            this.notify();
        }
    }
    public void method2() throws InterruptedException {
        synchronized (this){
            if(flag != 2){
                this.wait();
            }
            System.out.println("bbbbbbbb");
            flag = 1;
            this.notify();
        }
    }

}

三个或三个以上间的线程通信

public class Demo2_Notify3 {
    public static void main(String[] args) {
        Printer2 p = new Printer2();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                        p.method1();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                        p.method2();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                        p.method3();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }
}

class Printer2{
    private int flag = 1;
    public void method1() throws InterruptedException {
        synchronized (this){
            while (flag != 1){
                this.wait();
            }
            System.out.println("aaaa");
            flag = 2;
            this.notifyAll();
        }
    }
    public void method2() throws InterruptedException {
        synchronized (this){
            while (flag != 2){
                this.wait();
            }
            System.out.println("bbbbbbbb");
            flag = 3;
            this.notifyAll();
        }
    }
    public void method3() throws InterruptedException {
        synchronized (this){
            while (flag != 3){
                this.wait();
            }
            System.out.println("cccccccccccccc");
            flag = 1;
            this.notifyAll();
        }
    }
}

线程间通信注意的问题

1.在同步代码块中,用哪个对象锁,就用哪个对象调用wait方法
2.为什么wait方法和notify方法定义在Object这类中?
- 因为锁对象可以是任意对象,Object是所有的类的基类,所以wait方法和notify方法需要定义在Object这个类中
3.sleep方法和wait方法的区别?
- a,sleep方法必须传入参数,参数就是时间,时间到了自动醒来
- wait方法可以传入参数也可以不传入参数,传入参数就是在参数的时间结束后等待,不传入参数就是直接等待
- b,sleep方法在同步函数或同步代码块中,不释放锁,睡着了也抱着锁睡
- wait方法在同步函数或者同步代码块中,释放锁

互斥锁(重要) ReentrantLock Condition

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Demo3_ReentrantLock {
    public static void main(String[] args) {
        Printer3  p = new Printer3();
        new Thread(){
            @Override
            public void run() {
                while (true) {
                    try {
                        p.method1();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while (true) {
                    try {
                        p.method2();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while (true) {
                    try {
                        p.method3();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

    }
}
class Printer3{
    private int flag = 1;
    private ReentrantLock r = new ReentrantLock();
    Condition c1 = r.newCondition();
    Condition c2 = r.newCondition();
    Condition c3 = r.newCondition();
    public void method1() throws InterruptedException {
        r.lock();
            if (flag != 1){
                c1.await();
            }
            System.out.println("aaaa");
            flag = 2;
            c2.signal();
        r.unlock();
    }
    public void method2() throws InterruptedException {
        r.lock();
        if (flag != 2){
                c2.await();
            }
            System.out.println("bbbbbbbb");
            flag = 3;
            c3.signal();
        r.unlock();
    }
    public void method3() throws InterruptedException {
        r.lock();
            if(flag != 3){
                c3.await();
            }
            System.out.println("cccccccccccccc");
            flag = 1;
            c1.signal();
        r.unlock();
    }
}

线程组

public class Demo4_ThreadGroup {
    public static void main(String[] args) {
//        demo1();
        ThreadGroup threadGroup = new ThreadGroup("自造线程组");
        Mythread mythread = new Mythread();
        Runnable target;
        Thread t1 = new Thread(threadGroup, mythread);
        Thread t2 = new Thread(threadGroup,mythread,"线程1");
        Thread t3 = new Thread(threadGroup,mythread,"线程2");

        System.out.println(t1.getName());
        System.out.println(t2.getName());
        System.out.println(t3.getName());

        System.out.println(t1.getThreadGroup().getName());
        System.out.println(t2.getThreadGroup().getName());
        System.out.println(t3.getThreadGroup().getName());

        System.out.println(t1.getThreadGroup().getParent().getName());
    }

    private static void demo1() {
        Mythread mythread = new Mythread();
        Thread t1 = new Thread(mythread);
        Thread t2 = new Thread(mythread);

        ThreadGroup tg1 = t1.getThreadGroup();
        ThreadGroup tg2 = t2.getThreadGroup();
        System.out.println(tg1.getName());
        System.out.println(tg2.getName());
    }
}

class Mythread implements Runnable{
    @Override
    public void run() {

    }
}

线程的5种状态

新建线程.start() -> 线程就绪状态, 有执行权->抢到CPU执行权限执行->死亡状态, run执行完了
抢到CPU执行权限执行->wait或sleep线程阻塞->叫醒线,程线程就绪状态, 有执行权

线程池

程序创建一个线程成本比较高, 为了方便使用线程池, 使用后再返给JVM

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo5_Executors {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        pool.submit(new Mythread());
        pool.submit(new Mythread());

        pool.shutdown();
    }
}

实现Callable的线程

import java.util.concurrent.*;

public class Demo6_Callable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        Future<Integer> f1 =  pool.submit(new MyCallable(10));
        Future<Integer> f2 =  pool.submit(new MyCallable(20));
        System.out.println(f1.get());
        System.out.println(f2.get());

        pool.shutdown();
    }

}
class MyCallable implements Callable<Integer>{
    private int num;
    public MyCallable(int num){
        this.num = num;
    }
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for(int i=1;i<num;i++){
            sum = sum + i;
        }
        return sum;
    }
}

简单工厂模式

概述静态工厂方法模式, 它定义一个具体的工厂类负责创建一些类的实例
优点客户端不负责对象的创建, 从而明确各类的职责
缺点静态工厂负责所有类的创建, 如果有新的对象或者新对象创建方式不同, 就需要不断修改工厂类, 不利于后期维护.

public abstract class Animal {
    public void eat(){};
}

public class AnimalFactory {
    public static Dog createDog(){
        return new Dog();
    }
    public static Cat createCat(){
        return new Cat();
    }
    public static Animal createAnimal(String animal){
        if( "dog".equals(animal)){
            return new Dog();
        } else if( "cat".equals(animal)){
            return new Cat();
        }
        return null;
    }
}

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("单身狗儿吃狗粮");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = AnimalFactory.createDog();
        System.out.println(dog);

        Dog d = (Dog) AnimalFactory.createAnimal("dog");
        d.eat();

        Cat c = (Cat) AnimalFactory.createAnimal("cat");
        c.eat();
    }
}

工厂方法模式

工厂方法模式中看网易工厂类负责定义创建对象的接口, 具体对象的创建工作由继承工厂的具体类实现
做点
- 客户端不需要在负责对象的创建, 从而明确了各个类的职责, 如果有新的对象增加, 只需要增加一个具体的类和
- 俱体的工厂类即可, 不影响已有的代码, 后期维护容易, 增强了系统扩展性
缺点需要额外编写代码, 增加工作量

public abstract class Animal {
    public void eat(){};
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("单身狗儿吃狗粮");
    }
}

public interface Factory {
    public Animal createAnimal();
}

public class CatFactory implements Factory{
    @Override
    public Animal createAnimal() {
        return new Cat();
    }
}

public class DogFactory implements Factory{
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

public class Test {
    public static void main(String[] args) {
        DogFactory dogFactory = new DogFactory();
        Dog d = (Dog) dogFactory.createAnimal();
        d.eat();

        CatFactory catFactory = new CatFactory();
        Cat c = (Cat) catFactory.createAnimal();
        c.eat();
    }
}

Gui 了解, 暂用不到

import java.awt.*;

public class Demo1_Frame {
    public static void main(String[] args) {
        Frame f = new Frame();

        f.setTitle("我的窗口");
        f.setLocation(500,400);
        f.setSize(400,300);
        f.setIconImage(Toolkit.getDefaultToolkit().createImage("favicon.png"));
        f.setVisible(true);
    }
}

布局和按钮

import java.awt.*;

public class Demo1_Frame {
    public static void main(String[] args) {
        Frame f = new Frame();

        f.setTitle("我的窗口");
        f.setLocation(500,400);
        f.setSize(400,300);
        f.setIconImage(Toolkit.getDefaultToolkit().createImage("favicon.png"));
        f.setLayout(new FlowLayout());
        Button button = new Button("按钮");
        Button button2 = new Button("按钮");
        f.add(button);
        f.add(button2);

        f.setVisible(true);
    }
}

监听的3种方式

类实现WindowListener接口
类继承WindowAdapter
匿名内部类 new WindowAdapter()

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class Demo1_Frame {
    public static void main(String[] args) {
        Frame f = new Frame();

        f.setTitle("我的窗口");
        f.setLocation(500,400);
        f.setSize(400,300);
        f.setLayout(new FlowLayout());
        Button button = new Button("按钮");
//        MyWindow myWindow = new MyWindow();
//        f.addWindowListener(myWindow);
//        MyAdapter myAdapter = new MyAdapter();
//        f.addWindowListener(myAdapter);
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        f.add(button);

        f.setVisible(true);
    }
}

class MyAdapter extends WindowAdapter{
    @Override
    public void windowClosing(WindowEvent e) {
        System.exit(0);
    }
}

class MyWindow implements WindowListener{
    @Override
    public void windowOpened(WindowEvent e) {
    }

    @Override
    public void windowClosing(WindowEvent e) {
        System.exit(0);
    }

    @Override
    public void windowClosed(WindowEvent e) {
        System.out.println("Colosed");
    }

    @Override
    public void windowIconified(WindowEvent e) {
    }

    @Override
    public void windowDeiconified(WindowEvent e) {
    }
    @Override
    public void windowActivated(WindowEvent e) {

    }
    @Override
    public void windowDeactivated(WindowEvent e) {
    }
}

鼠标监听

同样有3种方式
实现MouseListener 接口
继承MouseAdapter抽象类
匿名内部类new MouseAdapter

import java.awt.*;
import java.awt.event.*;

public class Demo1_Frame {
    public static void main(String[] args) {
        Frame f = new Frame();

        f.setTitle("我的窗口");
        f.setLocation(500,400);
        f.setSize(400,300);
        f.setLayout(new FlowLayout());
        Button button = new Button("按钮");
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        f.add(button);
        button.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseReleased(MouseEvent e) {
                System.exit(0);
            }
        });

        f.setVisible(true);
    }
}

键盘监听和键盘事件

实现KeyListener 接口
继承 KeyAdapter 抽象类
匿名内部类new KeyAdapter()

import java.awt.*;
import java.awt.event.*;

public class Demo1_Frame {
    public static void main(String[] args) {
        Frame f = new Frame();

        f.setTitle("我的窗口");
        f.setLocation(500,400);
        f.setSize(400,300);
        f.setLayout(new FlowLayout());
        Button button = new Button("按钮");
//        MyWindow myWindow = new MyWindow();
//        f.addWindowListener(myWindow);
//        MyAdapter myAdapter = new MyAdapter();
//        f.addWindowListener(myAdapter);
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        f.add(button);
        button.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseReleased(MouseEvent e) {
                System.exit(0);
            }
        });
        button.addKeyListener(new KeyAdapter() {
            @Override
            public void keyReleased(KeyEvent e) {
                if(e.getKeyCode() == KeyEvent.VK_SPACE){
                    System.exit(0);
                }
            }
        });

        f.setVisible(true);
    }
}

动作监听

实现ActionListener 接口
匿名内部类 new ActionListener()类

import java.awt.*;
import java.awt.event.*;

public class Demo1_Frame {
    public static void main(String[] args) {
        Frame f = new Frame();

        f.setTitle("我的窗口");
        f.setLocation(500,400);
        f.setSize(400,300);
        f.setLayout(new FlowLayout());
        Button button = new Button("按钮");
        Button button2 = new Button("按钮二");
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        f.add(button);
        f.add(button2);
        button.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseReleased(MouseEvent e) {
                System.exit(0);
            }
        });
        button.addKeyListener(new KeyAdapter() {
            @Override
            public void keyReleased(KeyEvent e) {
                if(e.getKeyCode() == KeyEvent.VK_SPACE){
                    System.exit(0);
                }
            }
        });
        button2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.exit(0);
            }
        });
        f.setVisible(true);
    }
}

设计模式-适配器模式

什么是适配器
- 在使用监听器的时候, 需要定义一个事件监听器的接口
- 通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐
- 我在楼下器简化了这些操作, 我们定义监听器时只要继承我在楼下器, 然后重写需要的方法即可
适配器原理
- 适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的
- 我在楼下器类需要定义成抽象的, 因为创建类对象, 调用空方法是没有意义的
- 目的就是为了简化程序员的操作, 定义监听时继承适配器, 中重写需要的方法就可以了

GUI(需要知道的)

事件处理
- 事件: 用户的一个操作
- 事件源: 被操作的组件
- 监听器: 一个自定义类的对象, 实现了监听器接口, 包含事件处理方法, 监听器添加在事件源上, 当事件发生的时候虚拟机就会自动调用监听器中的事件处理方法

Java的多线程一 Li.046

Fri, 10 Sep 2021 11:20:14 +0800

多线程增加效率

并行, 就是多个任务同时进行, 多核cpu同时执行
并发, 多个任务轮流进行, cpu一个一个的执行

证明 JVM 是多线程的

垃圾回收和main线程间隔执行

public class Demo1_Thread {
    public static void main(String[] args) {
        for(int i=0; i < 10000000 ;i++){
            new Demo();
        }
        for(int i=0; i < 10000 ; i++){
            System.out.println("主线程");
        }
    }
}
class Demo{
    @Override
    protected void finalize() throws Throwable {
        System.out.println("垃圾被回收了");
    }
}

继承Thread 开启一个线程

实际run() 方法
start() 开启线程

public class Demo2_ExtendsThread {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
//        mt.run();
        mt.start();
        for (int i=0; i <10000 ; i++){
            System.out.println(i+"bbbbbbbbbbbbb");
        }
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0; i < 10000 ;i++){
            System.out.println(i+"aaaaaaaaaaaaaaa");
        }
    }
}

实际 Runnable 接口的类

实际Runnable类, 类作为参数传递给线程, start() 开启线程

public class Demo3_Runnable {
    public static void main(String[] args) {
        MyRunnable d =  new MyRunnable();
        Thread t = new Thread(d);
        t.start();
        for(int i=0; i < 10000 ;i++){
            System.out.println(i+"bbbbbbbbbbbbbbb");
        }

    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i=0; i < 10000 ;i++){
            System.out.println(i+"aaa");
        }
    }
}

多线程的2种区别

继承 Thread: 由于子类重写了Thread类的run()方法, 当调用start()时, 直接找子类的run()方法
实际 Runnable: 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run() 方法时内部判断成员变量Runnable的引用是否为空,
不为空看的Runnable的run(), 运行时是子类的run()方法.
继承Thread实现简单, 方便使用, 有父类则不能使用这种方法
有父类时可以实际Runnable 接口实现多线程, 对继承Thread的补充, 使用时必须获取线程对象, 使用复杂

匿名内类实现多线程的方法

public class Demo4_NoNameThread {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for(int i=0; i<100000 ;i++){
                    System.out.println("aaaaaa");
                }
            }
        }.start();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10000;i++){
                    System.out.println("bbbbbbbbbbbbbbbbbbb");
                }
            }
        });
        t.start();
    }
}

匿名内部类设置线程名字

public class Demo5_ThreadName {
    public static void main(String[] args) {
//        demo1();
        Thread t =  new Thread(){
            @Override
            public void run() {
//                this.setName("小明");
                System.out.println(this.getName()+"aaaaa");
            }
        };
        t.setName("李明");
        t.start();
        new Thread(){
            @Override
            public void run() {
                this.setName("小明");
                System.out.println(this.getName()+"aaaaa");
            }
        }.start();
    }

    private static void demo1() {
        new Thread("小明"){
            @Override
            public void run() {
                System.out.println(this.getName()+ "aaaaa");
            }
        }.start();
        new Thread("小红"){
            @Override
            public void run() {
                System.out.println(this.getName()+ "bbbbbb");
            }
        }.start();
    }
}

也可调用setName更改名称 获取本类的引用Thread.currentThread()

public class Demo6_GetName {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        Thread.currentThread().setName("主线程");
        System.out.println(Thread.currentThread().getName());
        new Thread( new Runnable() {

            @Override
            public void run() {
                System.out.println("dkf"+Thread.currentThread().getName());
            }
        }).start();
    }
}

休眠线程

public class Demo7_ThreadSleep {
    public static void main(String[] args) throws InterruptedException {
//        demo1();
        new Thread(){
            @Override
            public void run() {
                for (int i=0;i<10;i++) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName()+"a");
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                for (int i=0;i<10;i++) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName()+"bbbb");
                }
            }
        }.start();
    }

    private static void demo1() throws InterruptedException {
        for (int i=0; i<100;i++){
            Thread.sleep(1000);
            System.out.println(i);
        }
    }
}

守护线程

守护线程不会单独执行, 其他线程执行完了, 自动结束守护线程
final void setDaemon(boolean on)

public class Demo8_GudarThread {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i =0;i<2;i++){
                    System.out.println(getName()+i);
                }
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i =0;i<50;i++){
                    System.out.println(getName()+"aaaaaaaaaaa");
                }
            }
        };
        t2.setDaemon(true);
        t1.start();
        t2.start();
    }
}

加入线程

final void join() throws InterruptedException 插队执行线程
final void join(long millis) throws InterruptedException 插队执行m毫秒后, 再交其他线程

public class Demo9_ThreadJoin {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i =0;i<100;i++){
                    System.out.println(getName()+i);
                }
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i =0;i<100;i++){
                    if(i == 2) {
                        try {
                            t1.join();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(getName()+"aaaaaaaaaaa");
                }
            }
        };
        t1.start();
        t2.start();

    }
}

礼让线程, 了解即可

public class Demo10_Yield {
    public static void main(String[] args) {
        new MyThread2().start();
        new MyThread2().start();

    }
}

class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i=0;i<1000;i++) {
            if(0 == i%10){
                Thread.yield();
            }
            System.out.println(getName()+" "+i);
        }
    }
}

线程优先级

final void setPriority(int newPriority) 设置线程的优先级, 小范围1-10

public class Demo11_Priority {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                for (int i=0;i<100;i++){
                    System.out.println(getName()+"aaa");
                }
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i=0;i<100;i++){
                    System.out.println(getName()+"bbb");
                }
            }
        };
        t2.setPriority(Thread.MIN_PRIORITY);
        t.setPriority(Thread.MAX_PRIORITY);
        t.start();
        t2.start();
    }
}

线程同步

当多线程执行到一段代码块时, 不希望线程切换其他线程
synchronized 关键字锁对象到定义一段代码块, 同步代码块
锁对象是任意的, 锁对象不能是匿名对象

public class Demo1_Synchronized {
    public static void main(String[] args) {
        Printer p = new Printer();
        new Thread(){
            @Override
            public void run() {
                while (true) {
                    p.eatApple();
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while (true) {
                    p.eatMeet();
                }
            }
        }.start();
    }
}

class Printer{
    Demo d = new Demo();
    public  void eatApple(){
        synchronized (d) {
            System.out.print("a");
            System.out.print("a");
            System.out.print("a");
            System.out.print("a");
            System.out.print("a");
            System.out.print("a");
            System.out.println();
        }
    }
    public  void eatMeet(){
        synchronized (d) {
            System.out.print("b");
            System.out.print("b");
            System.out.print("b");
            System.out.print("b");
            System.out.print("b");
            System.out.print("b");
            System.out.println();
        }
    }
}
class Demo{}

同步方法

非静态方法的锁对象是this
静态方法的锁对象是字节码对象

package com.lizicai.sync;

public class Demo2_Syn {
    public static void main(String[] args) {
        Printer2 p = new Printer2();
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    p.eatApple();
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                while (true) {
                    p.eatMeet();
                }
            }
        }.start();
    }
}
class Printer2{
    Demo d = new Demo();
    synchronized public  void eatApple(){
        System.out.print("a");
        System.out.print("a");
        System.out.print("a");
        System.out.print("a");
        System.out.print("a");
        System.out.print("a");
        System.out.println();
    }

    public  void eatMeet(){
        synchronized (this) {
            System.out.print("b");
            System.out.print("b");
            System.out.print("b");
            System.out.print("b");
            System.out.print("b");
            System.out.print("b");
            System.out.println();
        }
    }
}
class Demo2{
}

public class Demo3_SynStaticMethod {
    public static void main(String[] args) {
        Printer3 p = new Printer3();
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    Printer3.eatApple();
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                while (true) {
                    Printer3.eatMeet();
                }
            }
        }.start();
    }
}
class Printer3{
    Demo d = new Demo();
    synchronized public static void eatApple(){
        System.out.print("a");
        System.out.print("a");
        System.out.print("a");
        System.out.print("a");
        System.out.print("a");
        System.out.print("a");
        System.out.println();
    }

    public static void eatMeet(){
        synchronized (Printer3.class) {
            System.out.print("b");
            System.out.print("b");
            System.out.print("b");
            System.out.print("b");
            System.out.print("b");
            System.out.print("b");
            System.out.println();
        }
    }
}

模拟卖票

使用唯一对象字节对象作为锁
或者使用静态的对象作为锁

public class Demo4_SynSoldTicket {
    public static void main(String[] args) {
        new Ticket().start();
        new Ticket().start();
        new Ticket().start();
        new Ticket().start();

    }
}
class Ticket extends Thread{
    private static int tickets = 100;
    private static Object obj = new Object();

    @Override
    public void run() {
        while (true){
//            synchronized (obj){
            synchronized (Ticket.class) {
                if( tickets <= 0){
                    break;
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(getName()+"-Ticket"+tickets--);
            }
        }
    }
}

火车站卖票 Runnable接口方式

多次启动start()非法

public class Demo5_SynSoldTicket {
    public static void main(String[] args) {
        Ticket2 tc = new Ticket2();
        new Thread(tc).start();
        new Thread(tc).start();
        new Thread(tc).start();
        new Thread(tc).start();
    }
}
class Ticket2 implements Runnable{

    private int tickets = 100;
    @Override
    public void run() {
        while (true) {
            // Ticket2.class 也可
//            synchronized (Ticket2.class) {
            synchronized (this) {
                if( tickets <= 0){
                    break;
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"-Ticket"+tickets--);
            }
        }
    }
}

多线程死锁

避免同步代码块嵌套, 容易造成死锁

public class Demo6_SynDead {
    private static String s1 = "筷子左";
    private static String s2 = "筷子右";
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                while (true){
                    synchronized (s1){
                        System.out.println(getName()+"..."+s1+"等待"+s2);
                        synchronized (s2){
                            System.out.println(getName()+"...拿到"+s1+s2+"开饭");
                        }
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    synchronized (s2){
                        System.out.println(getName()+"..."+s2+"等待"+s1);
                        synchronized (s1){
                            System.out.println(getName()+"...拿到"+s2+s1+"开饭");
                        }
                    }
                }
            }
        }.start();
    }
}

线程安全的类

Vector 线程安全的, ArrayList线程不安全
StringBuffer 线程安全的, StringBuilder 线程不安全的
Hashtable 线程安全的, HashMap 线程不安全的
Connections 中有synchronizedList 等方法返回线程安全的列表ArrayList

Java的递归 Li.045

Wed, 08 Sep 2021 23:06:35 +0800

递归练习, 计算文件夹大小

import java.io.File;
import java.util.Scanner;

public class Demo1_FolderSize {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String strFolder = null;
        long size = 0;
        while (true){
            if( sc.hasNext()){
                strFolder = sc.nextLine();
                break;
            }
        }
        if( strFolder.equals(null)){
            System.out.println("不能为空");
        } else {
            File folder = new File(strFolder);
            if(folder.isFile()){
                size = folder.length();
            } else if(folder.isDirectory()){
                size = getSize(folder);
            } else if(! folder.exists()){
                System.out.println("文件夹不存在");

            }
        }
        System.out.println(size);
    }
    public static long getSize(File folder){
        long len = 0;
        File [] files = folder.listFiles();
        for(File subFile:files){
            if(subFile.isFile()){
                len = len + subFile.length();
            } else{
                len = len + getSize(subFile);
            }
        }
        return len;
    }
}

递归删除文件夹

删除文件内的文件
删除文件夹本身

import java.io.File;
import java.util.Scanner;

public class Demo2_DeleteFolder {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String strFolder = null;
        strFolder = getDir(sc);

        if( strFolder.equals(null)){
            System.out.println("不能为空");
        } else {
            File folder = new File(strFolder);
            if(folder.isFile()){
                folder.delete();
            } else if(folder.isDirectory()){
                deleteFolder(folder);
            } else if(! folder.exists()){
                System.out.println("文件夹不存在");
            }
        }
    }
    private static void deleteFolder(File folder) {
        File[] files = folder.listFiles();
        for (File f : files){
            if(f.isFile()){
                f.delete();
            } else if(f.isDirectory()){
                deleteFolder(f);
                f.delete();
            }
        }
        folder.delete();
    }

    public static String getDir(Scanner sc) {
        String strFolder;
        while (true){
            if( sc.hasNext()){
                strFolder = sc.nextLine();
                break;
            }
        }
        return strFolder;
    }
}

复制文件到指定文件夹下

源文件夹, 目标文件夹
在目标文件夹中创建源文件夹
遍历源文件夹, 文件则调用stream 复制到目标文件夹/源文件夹, 文件夹则递归调用

import java.io.*;

public class Demo3_MvFolder {
    public static void main(String[] args) throws IOException {
        File folderSrc = new File("test");
        File folderDes = new File("des");
        copyFile3(folderSrc, folderDes);
    }
    public static void copyFile3(File folderSrc, File folderDes) throws IOException {
        if(! folderDes.isDirectory()){
            System.out.println("请复制到文件夹中");
            return;
        }
        File newFolder = new File(folderDes, folderSrc.getName());
        newFolder.mkdir();
        for(File f : folderSrc.listFiles()){
            if( f.isFile()){
                fileStream(f.getAbsolutePath(), newFolder.getAbsolutePath()+"/"+f.getName());
            } else{
                copyFile3(f, newFolder);
            }
        }
    }
    public static void copyFile2(File folderSrc, File folderDes) throws IOException{
        if(! folderDes.isDirectory()){
            System.out.println("请复制到文件夹中");
            return;
        }
        File tempFolder = new File(folderDes.getAbsolutePath()+"/"+folderSrc.getName());
        if( folderSrc.isDirectory()){
            tempFolder.mkdir();
        }

        for( File f : folderSrc.listFiles()){
            if( f.isFile()){
                fileStream(f.getAbsolutePath(), tempFolder.getAbsolutePath()+"/"+f.getName());
            } else {
                copyFile2(f, tempFolder);
            }
        }
    }

    public static void copyFile(File folderSrc, File folderDes) throws IOException {
        if(! folderDes.isDirectory()){
            System.out.println("请复制到文件夹中");
            return;
        }
        if( folderSrc.isDirectory()){
            new File(folderDes.getAbsolutePath()+"/"+folderSrc).mkdir();
        }
        for(File f: folderSrc.listFiles()){
            if ( f.isFile()){
                fileStream(f.getAbsolutePath(), (folderDes.getAbsolutePath()+"/"+f.getPath()));
            } else if( f.isDirectory()){
                copyFile(f, folderDes);
            }
        }
    }

    public static void fileStream(String src, String desc) throws IOException{
        FileInputStream fis = new FileInputStream(src);
        int len;
        byte[] arr = new byte[1024*100];

        FileOutputStream fos = new FileOutputStream(desc);
        while ( (len = fis.read(arr)) != -1){
            fos.write(arr,0,len);
        }
        fis.close();
        fos.close();
    }
}

打印文件夹的内文件, 保持层级

import java.io.File;

public class Demo4_PrintFolder {
    public static void main(String[] args) {
        File folder = new File("test");
        int lev = 0;
        printFolder(folder, lev);
    }
    public static void printFolder(File folder , int lev){
        System.out.println(folder.getPath());
        for ( File f : folder.listFiles()){
            for (int i=0;i<=lev;i++){
                System.out.print("\t");
            }
            if(f.isFile()){
                System.out.println(f.getPath());
            } else {
            // lev不能用lev++或++lev, 改变了lev值
                printFolder(f, lev+1);
            }
        }
    }
}

斐波那契数列

public class Demo5_TwoZi {
    public static void main(String[] args) {
        System.out.println(twoZi(6));
    }
    public static int twoZi(int month){
        int sum = 0;
        if(month > 2){
            sum = twoZi(month-1) + twoZi(month-2);
        } else if(month == 2){
            sum = 1;
        } else if(1 == month){
            sum = 1;
        }
        return sum;
    }
}

1000的阶乘, 其中所有0和尾部0的个数

import java.math.BigInteger;

public class Demo6_1000JieChen {
    public static void main(String[] args) {
        BigInteger bi = new BigInteger("1");
        for(int i=1;i<=1000;i++) {
            BigInteger tmepBi = new BigInteger(i + "");
            bi = bi.multiply(tmepBi);
        }
        int sum = 0;
        String str = String.valueOf(bi);
        for(int i=0;i<str.length();i++){
            if('0'== (str.charAt(i))){
                sum++;
            }
        }
        int num = 0;
        for(int j=str.length()-1;j>=0;j--){
            if( '0' == str.charAt(j)){
                num++;
            } else {
                break;
            }
        }
        System.out.println(sum);
        System.out.println(num);
    }
}

约瑟夫环

import java.util.ArrayList;
import java.util.Iterator;

public class Demo7_LuckYue {
    public static void main(String[] args) {
        int num = 8;
        System.out.println(getLuck(num));
        System.out.println(getLuck2(num));
    }
    public static int getLuck2(int num) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        for(int i=1;i<= num;i++){
            arrayList.add(i);
        }
        int sum = 1;
        for(int i=0; arrayList.size()!=1;i++){
            if( i == arrayList.size() ){
                i = 0;
            }
            if(0 == sum % 3){
                arrayList.remove(i--);
            }
            sum ++;
        }
        return arrayList.get(0);
    }
    public static int getLuck(int num){
        ArrayList<Integer> arrayList = new ArrayList<>();
        for(int i=1;i<= num;i++){
            arrayList.add(i);
        }
        int sum = 0;
        while (arrayList.size() > 1){
            Iterator<Integer> iterator = arrayList.iterator() ;
            while (iterator.hasNext()){
                Integer i = iterator.next();
                // next()和remove方法依赖关系
                sum++;
                if(0 == sum % 3){
                    iterator.remove();
                }
            }
        }
        return arrayList.get(0);
    }
}

Java的IO其他流(及Properties) Li.044

Mon, 06 Sep 2021 16:17:32 +0800

序列流

SequenceInputStream 关闭时会关闭所有流

public class Demo1_Stream {
    public static void main(String[] args) throws IOException {
        FileInputStream fr1 = new FileInputStream("read1.md");
        FileInputStream fr2 = new FileInputStream("read2.md");
        SequenceInputStream sis = new SequenceInputStream(fr1,fr2);
        FileOutputStream fos = new FileOutputStream("read3.md");
        int b ;
        while ( ( b = sis.read()) != -1){
            fos.write(b);
        }
        sis.close();
        fos.close();
    }
    public static void demo1() throws IOException {
        FileInputStream fr1 = new FileInputStream("read1.md");
        FileOutputStream fos = new FileOutputStream("read3.md");
        int b;
        while ((b = fr1.read()) != -1) {
            fos.write(b);
        }
        fr1.close();
        FileInputStream fr2 = new FileInputStream("read2.md");
        while ((b = fr2.read()) != -1) {
            fos.write(b);
        }
        fr2.close();
        fos.close();
    }
}

IO 流整合多个

public class Demo1_Stream {
    public static void main(String[] args) throws IOException {
        Vector<FileInputStream> v = new Vector<>();
        FileInputStream fr1 = new FileInputStream("read1.md");
        FileInputStream fr2 = new FileInputStream("read2.md");
        v.add(fr1);
        v.add(fr2);
        Enumeration<FileInputStream> en = v.elements();
        SequenceInputStream sis = new SequenceInputStream(en);
        FileOutputStream fos = new FileOutputStream("read3.md");
        int b ;
        while ( (b = sis.read()) != -1){
            fos.write(b);
        }
        sis.close();
        fos.close();
    }
}

ByteArrayOutputStream 获取数据

ByteArrayOutputStream 的 toString 可直接转为默认或指定的字符

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class Deom2_ByteArrayOutputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fi = new FileInputStream("read1.md");
        ByteArrayOutputStream baos  = new ByteArrayOutputStream();
        int b ;
        while ( (b = fi.read()) != -1){
            baos.write(b);
        }
        fi.close();
        System.out.println(baos.toString());
        System.out.println(baos.toString("utf-8"));
    }

    private static void Demo1() throws IOException {
        FileInputStream fi = new FileInputStream("read1.md");
        byte[] arr = new byte[3];
        int len;
        while ( ( len = fi.read(arr)) != -1){
            System.out.println(new String(arr,0,len));
        }
        fi.close();
    }
}

内存输出

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo3_Test {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("read1.md");
        byte[] arr = new byte[5];
        int len;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();

        while ( (len = fis.read(arr)) != -1){
            bos.write(arr,0,len);
        }
        fis.close();
        System.out.println(bos.toString());
        bos.close();
    }
}

随机读和存 RandomAccessFile

import java.io.IOException;
import java.io.RandomAccessFile;

public class Demo4_RandomAccessFile {
    public static void main(String[] args) throws IOException {
//        Demo1();
        Demo2();
    }
    public static void Demo2() throws IOException{
        RandomAccessFile raf = new RandomAccessFile("random.txt","rw");
        int b;
        while ( (b = raf.read()) != -1){
            System.out.println(b);
        }
        raf.close();
    }

    private static void Demo1() throws IOException {
        RandomAccessFile raf = new RandomAccessFile("random.txt","rw");
        raf.write(97);
        raf.seek(10);
        raf.write(98);
        raf.close();
    }
}

对象操作流 ObjecOutputStream

输出对象流, 序列化

import com.lizicai.bean.Person;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Demo5_ObjectOutputStream {
    public static void main(String[] args) throws IOException {
        Person p1 = new Person("小明", 23);
        Person p2 = new Person("小红", 23);

        ObjectOutputStream oos = new ObjectOutputStream( new FileOutputStream("person.txt"));
        oos.writeObject(p1);
        oos.writeObject(p2);
        oos.close();
    }
}

读取对象流

import com.lizicai.bean.Person;

import java.io.*;

public class Deom6_ObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream oos = new ObjectInputStream(new FileInputStream("person.txt"));
        Person p1 = (Person) oos.readObject();
        System.out.println(p1.getName()+p1.getAge());
        Person p2 = (Person) oos.readObject();
        System.out.println(p2.getName()+p2.getAge());
    }
}

对象操作优化

对象放入集合中, 集合输出到流

import com.lizicai.bean.Person;

import java.io.*;
import java.util.ArrayList;

public class Demo7_OptimeObjectStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("hashSetPerson.txt"));
        ArrayList<Person> arrayList = new ArrayList<>();
        arrayList.add(new Person("小明",25));
        arrayList.add(new Person("小红",23));
        arrayList.add(new Person("小王",26));
        oos.writeObject(arrayList);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("hashSetPerson.txt"));
        ArrayList<Person> personArrayList = ( ArrayList<Person> ) ois.readObject();
        for(Person p : personArrayList){
            System.out.println(p.getName() + p.getAge());
        }
    }
}

IO 流增加 id 号

更改Person属性时更改serialVersionUID 可以准备知道原来Persion和现在Persion属性区别

import java.io.Serializable;

public class Person implements Serializable {

    private static final long serialVersionUID= 1L;

    private String name;
    private int age;

    public Person(){}
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

IO 基本数据流, DataInputStream DataOutputStream

import java.io.*;

public class Demo8_DataInputStream {
    public static void main(String[] args) throws IOException {
        Demo1();
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("outData.txt"));
        dos.writeInt(997);
        dos.writeInt(998);
        dos.writeInt(999);
        dos.close();
        DataInputStream dis = new DataInputStream(new FileInputStream("outData.txt"));
        int x = dis.readInt();
        int y = dis.readInt();
        int z = dis.readInt();
        System.out.println(x);
        System.out.println(y);
        System.out.println(z);
        dis.close();


    }

    private static void Demo1() throws IOException {
        FileOutputStream fos = new FileOutputStream("output.txt");
        fos.write(997);
        fos.close();
    }
    private static void Demo2() throws IOException {
        FileInputStream fis = new FileInputStream("output.txt");
        int b = fis.read();
        fis.close();
    }
}

打印流的概述和特点

PrintStream 和 PrintWriter 分别是打印的字节流和字符流
只操作数据目的
自动刷出作用不大

import java.io.*;

public class Demo9_PrintStream {
    public static void main(String[] args) throws IOException {
//        Demo2();
        PrintWriter pw = new PrintWriter(new FileOutputStream("printWriter.txt"), true);
        pw.println(97);
    }

    private static void Demo2() throws FileNotFoundException {
        PrintWriter pw = new PrintWriter("printWriter.txt");
        pw.println(97);
        pw.write(97);
        pw.flush();
        pw.close();
    }

    private static void demo1() {
        PrintStream p = System.out;
        p.println("Hello World!");
        p.write(97);
        p.close();
    }
}

标准输入输出流概述和输出语句

标准输入只有1个, 未关联到文件, 不用关闭, 关闭后无法打开了
标准输出流未关联文件, 也不用关闭

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;

public class Demo10_SystemInOut {
    public static void main(String[] args) throws IOException {
//        demo1();
        System.setIn(new FileInputStream("systemin.txt"));
        System.setOut(new PrintStream("systemout.txt"));
        InputStream is = System.in;
        PrintStream ps = System.out;
        int b;
        while ( ( b = is.read()) != -1){
            ps.write(b);
        }
        is.close();
        ps.close();

    }

    private static void demo1() throws IOException {
        InputStream is = System.in;
        int x = is.read();
        System.out.println(x);
        is.close();

        InputStream is2 = System.in;
        int y = is2.read();
        System.out.println(y);
    }
}

练习, 复制文件, 增加使用数组, 增加复制速度

import java.io.*;

public class Demo11_SystemInOutTest {
    public static void main(String[] args) throws IOException {
        System.setIn(new FileInputStream("systemin.txt"));
        System.setOut(new PrintStream("systemout.txt"));
        InputStream is = System.in;
        PrintStream ps = System.out;
        byte [] arr = new byte[1024];
        int len;
        while ( ( len = is.read(arr)) != -1){
            ps.write(arr,0,len);
        }
        is.close();
        ps.close();
    }
}

2种键盘录入方式

import java.util.Scanner;

public class Demo12_SystemIn {
    public static void main(String[] args) throws IOException {
//        demo1();
        Scanner sc = new Scanner(System.in);
        String s = null;
        if(sc.hasNext()){
            s = sc.nextLine();
        }
        System.out.println(s);
    }

    private static void demo1() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = br.readLine();
        System.out.println(line);
    }
}

Properties的概述和作为Map集合的使用

Object setProperty(String key, String value) 添加键值对
Enumeration propertyNames() 获取 key值枚举
String getProperty(String key) 根据key 值获取 value

import java.util.Enumeration;
import java.util.Properties;

public class Demo13_Properties {
    public static void main(String[] args) {
//        demo1();
        Properties pp = new Properties();
        pp.setProperty("name", "小明");
        pp.setProperty("tel", "12310001000");
        System.out.println(pp);
        Enumeration <String> en = (Enumeration<String>) pp.propertyNames();
        while ( en.hasMoreElements()){
            String key = en.nextElement();
            System.out.println(key+pp.getProperty(key));
        }

    }

    private static void demo1() {
        Properties p = new Properties();
        p.put("intA", 12);
        System.out.println(p);
    }
}

Properties 读和存

void load(InputStream inStream) throws IOException 读取文件
void store(OutputStream out, String comments) throws IOException 写到文件, comments 加入注释

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Properties;

public class Demo13_Properties {
    public static void main(String[] args) throws IOException {
        Properties pp = new Properties();
        System.out.println(pp);
        pp.load(new FileInputStream("config.properties"));
        System.out.println(pp);
        pp.setProperty("qq","123");
        System.out.println(pp);
        pp.store(new FileOutputStream("config.properties"), "utf-8");
    }
}

Java的Reader和Writer类 Li.043

Thu, 02 Sep 2021 16:43:49 +0800

FileReader 读取文件

import java.io.FileReader;
import java.io.IOException;

public class Demo1_FileReader {
    public static void main(String[] args) throws IOException {
//        Demo1();
        FileReader fr = new FileReader("m.txt");
        int b ;
        while ( (b = fr.read()) != -1){
            System.out.println((char)b);
        }
        fr.close();
    }

    private static void Demo1() throws IOException {
        FileReader fr = new FileReader("m.txt");
        int x = fr.read();
        System.out.println(x);
        System.out.println((char)x);
    }
}

FileWriter 字符写入文件

import java.io.FileWriter;
import java.io.IOException;

public class Demo2_FileWriter {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("output.txt");
        String s = "这只羊叫Leon";
        fw.write(s);
        fw.flush();
        fw.close();
    }
}

字符复制

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo3_ReaderWriter {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("input.txt");
        FileWriter fw = new FileWriter("output.txt");

        int b ;
        while ( (b = fr.read()) != -1){
            fw.write(b);
        }
        fr.close();
        fw.close();
    }
}

什么情况使用使用字符流

字符流也能复制文件, 但不推荐, 字节->字符, 字符->字节多一步转换
程序需要读取一段文本, 或都需要写入一段文本的时候可以使用字符流
读取的时候按字符读出, 不会出现半个中文
写出时可直接字符串写出, 不用转换为字节数组
图片类文件不能使用字符流复制, 丢失数据

自定义数组复制

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo4_ReaderWriter {

    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("input.txt");
        FileWriter fw = new FileWriter("output.txt");

        char[] arr = new char[1024];
        int len;
        while ( (len = fr.read(arr)) != -1){
            fw.write(arr, 0 , len);
        }
        fr.close();
        fw.close();
    }
}

BufferedReader 和 BufferedWriter 读取写入字符

import java.io.*;

public class Demo5_BufferedReader {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("input.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));
        int b ;
        while ( (b=br.read()) != -1){
            bw.write(b);
        }
        br.close();
        bw.close();
    }
}

BufferedReader readLine()方法, BufferedWriter 的newLine方法

newLine 没有放在write(line)后, 并写在循环内, 这样写多写一个空行

import java.io.*;

public class Demo6_ReadLine {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("input.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));
        String line ;
        if( (line = br.readLine() ) != null ){
            bw.write(line);
        }
        while (  (line = br.readLine()) != null){
            bw.newLine();
            bw.write(line);
        }
        br.close();
        bw.close();
    }
}

练习, 读取行, 并行数反向输出

流, 最好晚开早关

import java.io.*;
import java.util.ArrayList;

public class Demo7_ReverseLine {
    public static void main(String[] args) throws IOException {

        ArrayList<String> arrayList = new ArrayList<>();
        String str ;
        BufferedReader br = new BufferedReader(new FileReader("input.txt"));
        while( ( str=br.readLine()) != null){
            arrayList.add(str);
        }
        br.close();

        BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));
        for(int i= arrayList.size()-1;i>=0 ;i--){
            bw.write(arrayList.get(i));
            if( i == 0 ){
                break;
            }
            bw.newLine();
        }
        bw.close();
    }
}

LineNumberReader

import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

public class Demo8_LineNumberReader {
    public static void main(String[] args) throws IOException {
        LineNumberReader lnr = new LineNumberReader(new FileReader("input.txt"));
        String line;

        lnr.setLineNumber(3);
        while ( (line = lnr.readLine()) != null){
            System.out.println(lnr.getLineNumber() + " "+line);
        }
        lnr.close();
    }
}

装饰设计模式

使用被装饰的类, 对类中方法升级增加内容
好处
- 耦合性不强, 被装饰类的变化与装饰类的变化无关

public class Demo9_Wrap {
    public static void main(String[] args) {
        JiuCai j = new JiuCai(new Student());
        j.code();
    }
}
class Student {
    private String name;
    private int age;
    public void code(){
        System.out.println("C");
        System.out.println("Java");
    }
}
interface Coder{
    public void code();
}

class JiuCai implements Coder{
    JiuCai (Student stu){
        this.stu = stu;
    }
    private Student stu;
    @Override
    public void code() {
        stu.code();
        System.out.println("JavaEE");
        System.out.println("SprintBoot");
    }
}

使用指定被码表读写字符

utf8格式写到gbk中, 乱码

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo10_UTF8 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("utf8.txt");
        FileWriter fw = new FileWriter("gbk.txt");
        int b ;
        while (( b=fr.read()) != -1){
            fw.write(b);
        }
        fr.close();
        fw.close();
    }
}

private static void Demo2() throws IOException {
    InputStreamReader isr = new InputStreamReader(new FileInputStream("utf-8.txt"),"utf-8");
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"), "gbk");
    int b ;
    while ( ( b=isr.read()) != -1 ){
        osw.write(b);
    }
    isr.close();
    osw.close();
}

public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader
        (new InputStreamReader(new FileInputStream("utf-8.txt"),"utf-8"));
    BufferedWriter bw = new BufferedWriter
        (new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk"));
    int b ;
    while ( (b=br.read()) != -1){
        bw.write(b);
    }
    br.close();
    bw.close();

}

练习, 统计字符, 并输出到一个文件中

import java.io.*;
import java.util.Map;
import java.util.TreeMap;

public class Demo11_CalculatorChar {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader (new FileReader("utf-8.txt"));
        TreeMap<String,Integer> treeMap = new TreeMap<>();

        int b ;
        while ( (b=br.read()) != -1){
            if( treeMap.containsKey(String.valueOf((char)b))){
                treeMap.put(String.valueOf((char)b),treeMap.get(String.valueOf((char)b))+1);
            } else {
                treeMap.put(String.valueOf((char)b), 1);
            }
        }
        br.close();
        BufferedWriter bw = new BufferedWriter(new FileWriter("times.txt"));
        for(Map.Entry<String,Integer> stringIntegerEntry : treeMap.entrySet()){
            if( "\n".equals(stringIntegerEntry.getKey())){
                bw.write(stringIntegerEntry.getValue()+"="+"\\n");
            } else if( " ".equals(stringIntegerEntry.getKey()) ){
                bw.write(stringIntegerEntry.getValue()+"="+"space");
            } else {
                bw.write(stringIntegerEntry.getValue()+"="+stringIntegerEntry.getKey());
            }
            bw.newLine();
        }
        bw.close();
    }
}

模拟软件剩余使用次数

import java.io.*;

public class Demo12_CalculatorTimes {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("license.txt"));
        String str;
        str = br.readLine();
        br.close();
        int times = Integer.parseInt(str);
        if( times <= 0){
            System.out.println("试用结束, 请购买正版");
        } else if( times > 0){
            System.out.println("还可以使用"+times+"次");
            times = times - 1;
        }
        BufferedWriter bw = new BufferedWriter(new FileWriter("license.txt"));
        bw.write(String.valueOf(times));
        bw.close();
    }
}

递归

public static int demo1(int nu){
    if(nu > 1){
        nu = nu * demo1(nu - 1);
    }
    return nu;
}

递归找.java结尾的文件

import java.io.File;
import java.util.Scanner;

public class Demo14_DiGui2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str;
        while (true){
            if( sc.hasNext()){
                str=sc.nextLine();
                break;
            }
        }
        File file = new File(str);
        if(file.exists()){
            printJavaFile(file);
        } else{
            System.out.println("文件夹不存在");
        }
    }

    private static void printJavaFile(File file) {
        File[] arrayList ;
        arrayList = file.listFiles();
        for(File f : arrayList) {
            if (f.isDirectory()) {
                printJavaFile(f);
            } else if (f.isFile() && f.getName().endsWith(".java")) {
                System.out.println(f.getAbsoluteFile());
            }
        }
    }
}

Java的IO流 Li.042

Mon, 30 Aug 2021 17:04:54 +0800

Java 的 IO 流

字节流, 字节流可以操作任何数据, 计算机中存储是字节流
- InputStream
- OutputStream
字符流, 只能操作纯字符数据, 比较方便
- Reader
- Writer

使用IO流要导入包, 使用时要进行异常处理, 使用后要释放资源

FileInputStream 读取一个文件

import java.io.FileInputStream;
import java.io.IOException;

public class Demo1_FileInputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fps = new FileInputStream("test.txt");
        int x;
        while ((x = fps.read() ) != -1){
            System.out.println(x);
        }
        fps.close();
    }
}

read() 为什么接收的int类型

因为字节输入流可以操作任意类型的文件,比如图片音频等, 这些文件底层都是以二进制形式的存储的,如果每次读取都返回byte, 有可能在读到中间的时候遇到111111111,那么这11111111是byte类型的-1, 我们的程序是遇到-1就会停止不读了,后面的数据就读不到了,所以在读取的时候用int类型接收, 如果11111111会在其前面补上24个0凑足4个字节,那么byte类型的-1就变成int类型的255了这样可以保证整个数据读完, 而结束标记的-1就是int类型

字节输出流 write()

void write(int b) throws IOException 在输出时int 去掉前3个byte字节, 写入第4个byte到文件中, 这个写是覆盖

import java.io.FileOutputStream;
import java.io.IOException;

public class Deom2_FileOutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fps = new FileOutputStream("test.txt");
        fps.write(100);
        fps.write(101);
        fps.write(102);
        fps.close();
    }
}

字节输出流追加

FileOutputStream(File file, boolean append) throws FileNotFoundException 输出字节流是否选择追加

import java.io.FileOutputStream;
import java.io.IOException;

public class Demo3_FileOutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fps = new FileOutputStream("test.txt", true);
        fps.write(100);
        fps.write(101);
        fps.close();
    }
}

复制文件

byte字节读取, byte复制

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo4_FileInOutStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("test.txt");
        FileOutputStream fos = new FileOutputStream("copy.txt");
        int b = 0;
        while ( (b = fis.read() )!= -1){
            fos.write(b);
        }
        fis.close();
        fos.close();
    }
}

FileInputStream 的 available方法

int available() throws IOException 返回输入流的长度

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo5_FileInOutStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("test.txt");
        FileOutputStream fos = new FileOutputStream("copy.txt");

        int len = fis.available();
        byte[] arr = new byte[fis.available()];
        fis.read(arr);
        fos.write(arr);
        fis.close();
        fos.close();
    }
}

通过数组 byte[] 读取写入

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo6_FileInOutStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("test.txt");
        FileOutputStream fos = new FileOutputStream("copy.txt");

        byte[] arr = new byte[1024 * 1024];
        int b = 0;
        while ( (b =fis.read(arr)) != -1 ){
            fos.write(arr,0,b);
        }
        fis.close();
        fos.close();
    }

    private static void errSimple() throws IOException {
        FileInputStream fis = new FileInputStream("test.txt");
        FileOutputStream fos = new FileOutputStream("copy.txt");

        byte[] arr = new byte[3];
        int b = 0;
        while ( (b =fis.read(arr)) != -1 ){
            fos.write(arr);
        }
        fis.close();
        fos.close();
    }
}

BufferedInputStream BufferedOutputStream

原码先读取1024*8个字节到内存, 复制给 BufferedOutputStream 1024*8 然后才写入文件
只需要关闭BufferedInputStream BufferedOutputStream 就能关闭所有流

import java.io.*;

public class Demo7_BufferInputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("test.txt");
        FileOutputStream fos = new FileOutputStream("copy.txt");

        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        int b ;
        while( ( b = bis.read() ) != -1){
            bos.write(b);
        }
        // 只需关闭 BufferedInputStream BufferedOutputStream
        bis.close();
        bos.close();
    }
}

flush和close方法的区别

flush 刷新缓冲区, 缓冲区写到文件中, 刷完可以继续写.
close 关闭前就会刷新缓冲区将缓冲区内容存到文件中

import java.io.*;

public class Demo8_FlushClose {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("test.txt");
        FileOutputStream fos = new FileOutputStream("copy.txt");

        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        int b ;
        while ( (b = bis.read()) != -1 ){
            bos.write(b);
            bos.flush();
        }
        bis.close();
        bos.close();
    }

}

字节流读取中文有乱码

UTF-8中英文1个字节, 中文3个字节, 按字节读取都会读出乱码

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class Demo9_CharIO {
    public static void main(String[] args) throws IOException {
//        Demo1();
        FileOutputStream fos = new FileOutputStream("chinese.txt");
        fos.write("你好啊, 世界!".getBytes(StandardCharsets.UTF_8));
        fos.write("\r".getBytes(StandardCharsets.UTF_8));
        fos.close();
    }

    private static void Demo1() throws IOException {
        FileInputStream fis = new FileInputStream("chinese.txt");
        byte[] arr = new byte[3];
        String s;
        int len ;
        while ( ( len=fis.read(arr) ) != -1){
            System.out.println(new String(arr,0,len));
        }
    }
}

异常处理

流初始化null
try 关闭流
能关闭一个就关闭一个

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo10_IOException {
    public static void main(String[] args) throws IOException{
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("test.txt");
            fos = new FileOutputStream("copy.txt");
        }
        finally {
            try{
                if(null != fis){
                    fis.close();
                }
            } finally {
                if(null != fos){
                    fos.close();
                }
            }
        }
    }
}

图片加密解密

加密把输出的字节异或一个数, 解密时再异或这个数

import java.io.*;
public class Demo12_Encrypt {
    public static void main(String[] args)  throws IOException {
        String src = "beauty.png";
        String dest = "copy.png";
        String dest2 = "copy1.png";
//        extracted(src, dest);
        extracted(dest, dest2);
    }

    private static void extracted( String src, String dest) throws IOException {
        BufferedInputStream fis = new BufferedInputStream(new FileInputStream(src));
        BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream(dest));
        int b ;
        while ( (b = fis.read()) != -1){
            fos.write(b ^ 123 );
        }
        fis.close();
        fos.close();
    }
}

输入文件复制到当前路径下

import java.io.*;
import java.util.Scanner;

public class Demo13_CopyFile {
    public static void main(String[] args) throws IOException {

        Scanner sc = new Scanner(System.in);
        String src = null;
        if(sc.hasNext()){
            src = sc.nextLine();
        }
        BufferedInputStream fis =null;
        int b ;
        BufferedOutputStream fos = null;
        if(src != null){
            File file = new File(src);
            fis = new BufferedInputStream(new FileInputStream(src));
            fos = new BufferedOutputStream(new FileOutputStream("./"+file.getName()));
            if( file.isFile()){
                 while ( (b = fis.read()) != -1){
                     fos.write(b);
                 }
            } else if( file.isDirectory()){
                System.out.println("文件夹无法复制");
            }
        }
        fis.close();
        fos.close();
    }
}

练习, 录入输入字符到文件中

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class Demo14_InputKey {
    public static void main(String[] args) throws IOException {
        Scanner sc  = new Scanner(System.in);
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt", true));
        String input = null;
        while ( sc.hasNext()){
            input = sc.nextLine();
            if( "quit".equals(input)){
                break;
            } else{
                bos.write(input.getBytes(StandardCharsets.UTF_8));
                bos.write("\n".getBytes(StandardCharsets.UTF_8));
            }
        }
        bos.close();
    }
}

Java的File类 Li.041

Sun, 29 Aug 2021 21:34:53 +0800

File

相对路径文件或目录
绝对路径文件或目录
File(String pathname) 文件路径或目录
File(String parent, String child) 父文件路径, 和子文件名
File(File parent, String child) 父文件路径file, 和子文件名

import java.io.File;

public class Demo1_File {
    public static void main(String[] args) {
//        Demo1();
//        Demo2();
        File parentFile = new File("/usr/local/etc/nginx/");
        String child = "nginx.conf";
        File file = new File(parentFile, child);
    }

    private static void Demo2() {
        String parent = "/usr/local/etc/nginx/";
        String child = "nginx.conf";
        File file = new File(parent,child);
        System.out.println(file.exists());
    }
    // a.c 与 src 在同级目录下
    private static void Demo1() {
        File file = new File("/usr/local/etc/nginx/nginx.conf");
        System.out.println(file.exists());
        File file2 = new File("a.c");
        System.out.println(file2.exists());
    }
}

File 的方法

boolean createNewFile() throws IOException 如果没有则创建true, 有则不创建false.
boolean mkdir() 无则创建文件夹, 有则不创建false
boolean mkdirs() 无则创建多级文件夹, 有则不创建false

import java.io.File;
import java.io.IOException;

public class Demo2_FileMethod {
    public static void main(String[] args) throws IOException {
        File file = new File("aaa.c");
        System.out.println(file.createNewFile());

        File file2 = new File("test");
        System.out.println(file2.mkdir());

        File file3 = new File("test/aaa");
        System.out.println(file3.mkdirs());
    }
}

boolean renameTo(File dest) 就是mv命令
boolean delete() 删除文件或删除空文件夹, 文件夹内有文件或文件夹(空的也算)则删除不了

import java.io.File;
import java.io.IOException;

public class Demo3_FileMethod {
    public static void main(String[] args) throws IOException {
        File file1 = new File("aaa.c");
        File file2 = new File("bbb.c");
        System.out.println(file1.renameTo(file2));
        System.out.println(file2.delete());

        File file3 = new File("test/aaa");
        System.out.println(file3.delete());

        File file4 = new File("test/ccc");
        System.out.println(file4.mkdirs());
        file4.delete();
        File file5 = new File(  "test");
        System.out.println(file5.delete());
    }
}

boolean isDirectory() 判断是否文件夹
boolean isFile() 判断是否文件
boolean exists() 判断是否存在
boolean canRead() 判断是否可读权限
boolean canWrite() 判断是否可写权限
boolean isHidden() 判断是否隐藏

import java.io.File;
import java.io.IOException;

public class Demo4_FileMethod {
    public static void main(String[] args) throws IOException {
        File file1 = new File("test");
        System.out.println(file1.isDirectory());

        File file2 = new File("test.c");
        System.out.println(file1.isFile());
        System.out.println(file2.isFile());

        File file3 = new File("aaa.c");
        System.out.println(file3.exists());
        System.out.println(file3.createNewFile());
        System.out.println(file3.exists());

        File file4 = new File("ccc.c");
        System.out.println(file4.createNewFile());
        System.out.println(file4.canRead());

        File file5 = new File("ddd.c");
        System.out.println(file5.createNewFile());
        System.out.println(file5.canWrite());

        File file6 = new File("root.c");
        System.out.println(file6.setReadable(false));
        System.out.println(file6.canRead());
        System.out.println(file6.canWrite());

        File file7 = new File("test.c");
        System.out.println(file7.isHidden());

        File file8 = new File(".idea");
        System.out.println(file8.isHidden());
    }
}

String getAbsolutePath()
String getPath()
String getName()
long length()
long lastModified()
String[] list()
File[] listFiles()

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo5_FileMethod {
    public static void main(String[] args) {
        File file = new File("aaa.c");
        File file2 = new File("/Users/test/IdeaProjects/day19/");
        System.out.println(file.getAbsoluteFile());
        System.out.println(file2.getAbsoluteFile());


        System.out.println(file.getPath());
        System.out.println(file2.getPath());

        System.out.println(file.getName());
        System.out.println(file2.getName());

        System.out.println(file.length());
        System.out.println(file2.length());

        System.out.println(file.lastModified());
        System.out.println(file2.lastModified());
        Date date = new Date(file.lastModified());
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(simpleDateFormat.format(date));


        String [] arr = file.list();
//        for(String s: arr){
//            System.out.println(s);
//        }
        String [] arr2 = file2.list();
        for(String s: arr2){
            System.out.println(s);
        }

        File[] list1 = file.listFiles();
//        for(File f : list1){
//            System.out.println(f);
//        }
        File[] list2 = file2.listFiles();
        for(File f : list2){
            System.out.println(f);
        }
    }
}

练习查找文件夹下所有的.c结尾的文件

遍历所有的文件, 碰到文件夹则进入遍历
文件名字正则匹配, 匹配输出
或使用String endsWith 匹配

import java.io.File;

public class Demo6_FileTest {
    public static void main(String[] args) {
        File file = new File("/Users/test/workplace/test");
        File file2 = new File("/Users/test/workplace/test");
        File[] arrFile = file.listFiles();
        File[] arrFile2 = file2.listFiles();
        String regex = ".*[\\.][c]$";
        String strEnd = ".c";
        fileFind(arrFile, strEnd);
        fileFindRegex(arrFile2, regex);

    }
    public static void fileFind(File[] file, String strEnd){
        for(File f : file){
            if(f.isDirectory()){
                fileFind(f.listFiles(), strEnd);
            } else{
                if( f.getName().endsWith(strEnd) ){
                    System.out.println(f.getName());
                }
            }
        }
        return ;
    }
    public static void fileFindRegex(File[] file, String regex){
        for(File f : file){
            if(f.isDirectory()){
                fileFindRegex(f.listFiles(), regex);
            } else{
                if( f.getName().matches(regex) ){
                    System.out.println(f.getName());
                }
            }
        }
        return ;
    }
}

String[] list(FilenameFilter filter) 实现FilenameFilter 接口, 返回匹配的数组

原码

public String[] list(FilenameFilter filter) {
    String names[] = list();
    if ((names == null) || (filter == null)) {
        return names;
    }
    List<String> v = new ArrayList<>();
    for (int i = 0 ; i < names.length ; i++) {
        if (filter.accept(this, names[i])) {
            v.add(names[i]);
        }
    }
    return v.toArray(new String[v.size()]);
}

练习, test下.c结尾的文件, 仅有一级目录

import java.io.File;
import java.io.FilenameFilter;

public class Demo7_FileMethod {
    public static void main(String[] args) {
        File dir = new File("/Users/test/workplace/test");
        String [] arr = dir.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File file = new File(dir, name);
                return file.isFile() && file.getName().endsWith(".c");
            }
        });

        for (String str : arr){
            System.out.println(dir+"/" + str);
        }
    }
}

Java的异常类 Li.040

Fri, 27 Aug 2021 17:14:29 +0800

Java 的异常类

异常的体系

Throwable
- Error
- Exception
  - RuntimeException

如果程序没有处理异常, JVM 自行处理, 把异常的名称和信息, 打印在控制台上.

异常的2种处理方式

try catch finally
- try catch
- try catch finally
- try finally
throws

public class Demo1_Exception {
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        int x;
        try{
            x = demo1.div(10,0);
        } catch (ArithmeticException e){
            System.out.println(e.getClass());
            System.out.println("test");
        }finally {
            System.out.println("最后执行了吗");
        }
    }
}
class Demo1 {
    public int div (int a, int b){
        return a/b;
    }
}

public class Demo2_Exception {
    public static void main(String[] args) {
        int a = 0;
        int b = 10;
        int[] arr = {1, 2, 3};
        int x ;
        arr = null;
        try {
//            x = b / a;
            System.out.println(arr[10]);
        } catch (ArithmeticException e){
            System.out.println(e.getClass());
        } catch (IndexOutOfBoundsException e){
            System.out.println(e.getClass());
        } catch (Exception e){
            System.out.println("有异常");
        }
    }
}

public class Demo3_Exception {
    public static void main(String[] args) {
        try {
            System.out.println(10/0);
        } catch (ArithmeticException | IndexOutOfBoundsException  e){
            System.out.println("Exception");
        }
    }
}

异常throwable 的方法

String getMessage() 获取异常信息
String toString() 获取异常类和异常信息
void printStackTrace() 获取异常类和异常信息, 异常在程序出现的位置

public class Demo3_Exception {
    public static void main(String[] args) {
        try {
            System.out.println(10/0);
        } catch (ArithmeticException | IndexOutOfBoundsException  e){
            System.out.println(e.getMessage());
            System.out.println(e.toString());
            e.printStackTrace();
        }
    }
}

方法上的2种异常

RuntimeException 运行时异常, 不需要在方法向上抛出, 使用的时候也不需要在使用的方法上向上抛出
非RuntimeException 的异常, 必须在方法上向上抛出, 使用方法时也必须向上抛出异常

import lombok.Getter;
import lombok.Setter;

public class Person {
    public Person(){}
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    @Getter
    @Setter
    private String name;
    @Getter
    private int age;

    public void setAge(int age)  {
        if(age < 1 || age > 150){
            throw new RuntimeException ("年龄非法");
        }
        this.age = age;
    }
}

import lombok.Getter;
import lombok.Setter;

public class Person {
    public Person(){}
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    @Getter
    @Setter
    private String name;
    @Getter
    private int age;

    public void setAge(int age)  throws Exception{
        if(age < 1 || age > 150){
            throw new Exception ("年龄非法");
        }
        this.age = age;
    }
}

public class Demo4_Exception {
    public static void main(String[] args) throws Exception{
        Person p = new Person();
        p.setAge(-12);
        System.out.println("MM");
    }
}

throws 和 throw 区别

throws
- 用在方法声明后, 跟的是异常类名
- 跟以跟多个类名, 用逗号隔开
- 表示抛出异常, 由该方法的调用者处理
throw
- 用在方法内, 跟的是异常对象名
- 只能抛出一个异常对象名
- 表示抛出异常, 由方法体内的语句处理

finally

finally 的特点
- 被finally 控制的语句一定会执行
- 特殊情况: 在执行finally 前 JVM 退出了(如System.exit(0))
finally 的作用
- 用于释放资源, 在IO 操作和数据库操作中会见到
return 的区别 return 执行后, 如果有finally 则执行finally 类

public class Demo5_Exception {
    public static void main(String[] args) {
        try {
            System.out.println(1/0);
        } catch (Exception e){
            System.out.println("异常");
        } finally {
            System.out.println("最后一定执行");
        }
    }
}

final finally finalize 区别

final
- final 可以修饰类, 但不能被继承
- 修饰方法不能被重写
- 修饰变量只能赋值一次
finally
- try catch finally 体系中的一个语句, 不能单独使用
finalize
- 当垃圾回收器确定不存在该对象的更多引用时, 对象回收器则调用此方法

public class Demo6_Exception {
    public static void main(String[] args) {
        System.out.println(demo1());
    }
    public static int demo1(){
        int x = 10;
        try {
            x = 20;
            System.out.println(1/0);
            return x;
        } catch (Exception e){
            x = 30;
            return x;
        } finally {
            x = 40;
        }
    }
}

x 会返回30, return 把x=30装箱返回回去

自定义异常

为什么需要定义异常类
- 可通过异常类名字即可知道错误在哪
异常使用
- 自定义异常类, 继承Exception
- 在方法中使用异常类
- 调用方法时处理异常类(try catch finally)或直接抛出

public class OutOfAgeException extends Exception {
    public OutOfAgeException() {
        super();
    }

    public OutOfAgeException(String message) {
        super(message);
    }

    public OutOfAgeException(String message, Throwable cause) {
        super(message, cause);
    }

    public OutOfAgeException(Throwable cause) {
        super(cause);
    }

    protected OutOfAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

import com.lizicai.exception.OutOfAgeException;
import lombok.Getter;
import lombok.Setter;

public class Person {
    public Person(){}
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    @Getter
    @Setter
    private String name;
    @Getter
    private int age;

    public void setAge(int age)  throws Exception{
        if(age < 1 || age > 150){
            throw new OutOfAgeException("年龄异常");
        }
        this.age = age;
    }
}

public class Demo7_Exception {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        p.setAge(-10);
    }
}

异常

子类重写父类方法时, 子类的方法必须抛出相同的异常或父类异常的子类( 子类不能比父类坏的更多 )
如果父类抛出多个异常, 子类重写父类时, 只能抛出相同的异常或异常的子类, 子类不能抛出父类没有的异常
如果重写方法没有异常抛出, 那么子类的方法绝对不可以抛出异常, 如果子类方法内有异常发生, 那么子类能try catch,不能throws

练习

输入一个整数
超出整数范围则提示过大, 重新输入整数
输入小数则提示小数, 重新输入整数
输入字符等, 则提示非法字符, 请重新输入整数

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Scanner;

public class Demo8_Exception {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = null;
        BigInteger bigInteger = null;
        BigDecimal bigDecimal = null;
        int scInt = 0;
        System.out.println("请输入一个整数:");
        while (sc.hasNext()){
            str = sc.nextLine();
            try {
                scInt = Integer.parseInt(str);
                System.out.println(Integer.toBinaryString(scInt));
                break;
            } catch (Exception e){
                try {
                    bigInteger = new BigInteger(str);
                    System.out.println("过大的整数, 请重新输入整数");
                } catch (NumberFormatException e2){
                    try{
                        bigDecimal =  new BigDecimal(str);
                        System.out.println("输入的小数, 请重新输入整数");
                    } catch (Exception e3){
                        System.out.println("输入的非法字符, 请重新输入整数");
                    }
                }
            }
        }
    }
}

Java的Map类 Li.039

Tue, 24 Aug 2021 23:16:13 +0800

Map

将键映射到值的对象
一个映射不能包含重复的键
每个键最多只能映射到一个值

Map 与 Collection 接口的不同

Map 是双列的, Collection 是单列的
Map 是键唯一, Collection 的子体系Set是唯一的
Map 集合的数据结构值针对键有效, 跟值无关; Collection集合的数据结构是针对元素有效

Map 方法

V put(K key, V value) 添加键和值, 成功返回null, 覆盖重复key值, 则返回被覆盖的Value值
V remove(Object key) 通过key删除元素, 删除成功则返回Value值
boolean containsKey(Object key) Map 中是否包含Key值
boolean containsValue(Object value) Map 中是否包含Value值
boolean isEmpty() Map 是否为空
clear() 清空Map

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class Demo1_Map {
    public static void main(String[] args) {
//        Demo1();
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("小明", 18);
        hashMap.put("小红", 19);
        hashMap.put("小王", 20);
        System.out.println(hashMap);
        Integer i =  hashMap.remove("小王");
        System.out.println(i);
        System.out.println(hashMap);

        System.out.println(hashMap.containsKey("小明"));
        System.out.println(hashMap.containsValue(19));
        System.out.println(hashMap.isEmpty());

        Collection<Integer> v = hashMap.values();
        System.out.println(v);
        hashMap.clear();
        System.out.println(hashMap.size());

    }

    private static void Demo1() {
        Map<String,Integer> map = new HashMap<>();
        Integer i1 = map.put("s1",12);
        Integer i2 = map.put("s2",22);
        Integer i3 = map.put("s3",33);
        Integer i4 = map.put("s3",34);
        Integer i5 = map.put("s5",35);
        Integer i6 = map.put("s6",35);
        System.out.println(map);
        System.out.println(i4);
        System.out.println(i5);
        System.out.println(i6);
    }
}

Map 根据键获取值

import java.util.HashMap;

public class Demo2_Iterator {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();

        hashMap.put("a", 100);
        hashMap.put("b",90);
        hashMap.put("c",98);

        for(String s:hashMap.keySet()){
            System.out.println(s + "="+ hashMap.get(s));
        }
    }
}

Map 的键值对, 来获取Map中的Key 与 Value

import java.util.HashMap;
import java.util.Map;

public class Demo3_Iterator {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();

        hashMap.put("a", 90);
        hashMap.put("b",95);
        hashMap.put("c",98);

        for(Map.Entry<String,Integer> single: hashMap.entrySet()){
            System.out.println(single.getKey() + " "+ single.getValue());
        }
    }
}

HashMap 存入Student类和String时, 重写 hashCode 和 equals方法

import lombok.Getter;
import lombok.Setter;

import java.util.Objects;

public class Student {
    public Student(){}
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
    @Getter
    @Setter
    private String name;

    @Getter
    @Setter
    private int age;

    @Override
    public String toString() {
        return "Student "+this.name+this.age;
    }

    @Override public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public boolean equals(Object obj) {
        Student s = (Student) obj;
        return this.name == s.name && this.age == s.age;
    }
}

import com.lizicai.bean.Student;

import java.util.HashMap;

public class Demo4_HashMap {
    public static void main(String[] args) {
        HashMap<Student, String> hashMap = new HashMap<>();
        hashMap.put(new Student("小明",23), "上海");
        hashMap.put(new Student("小明",23), "北京");
        hashMap.put(new Student("小王",26), "北京");
        hashMap.put(new Student("莱昂纳多",28), "美国");
        System.out.println(hashMap);
    }
}

LinkedHashMap

import java.util.LinkedHashMap;

public class Demo5_LinkedHashMap {
    public static void main(String[] args) {
        LinkedHashMap<String,Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("a", 20);
        linkedHashMap.put("b", 20);
        linkedHashMap.put("c", 20);
        System.out.println(linkedHashMap);
    }
}

TreeMap 必须实现 Comparable 接口, 2种方式

方式一在bean类中实现Comparable 接口

import lombok.Getter;
import lombok.Setter;

import java.util.Objects;

public class Student implements Comparable<Student>{
    public Student(){}
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
    @Getter
    @Setter
    private String name;

    @Getter
    @Setter
    private int age;

    @Override
    public String toString() {
        return "Student "+this.name+this.age;
    }

    @Override public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public boolean equals(Object obj) {
        Student s = (Student) obj;
        return this.name == s.name && this.age == s.age;
    }

    @Override
    public int compareTo(Student o) {
        int numName = this.name.compareTo(o.name);
        int numAge = numName == 0 ? this.age-o.age : numName;
        return numAge;
    }
}

public class Demo6_TreeMap {
    public static void main(String[] args) {
//        Demo1();
        TreeMap<Student, String> treeMap = new TreeMap<>();
        treeMap.put(new Student("ab",23), "上海");
        treeMap.put(new Student("ab",23), "北京");
        treeMap.put(new Student("ac",26), "北京");
        treeMap.put(new Student("abc",28), "美国");

        System.out.println(treeMap);

    }
}

方式二, 在创建TreeMap时实现 Comparator 接口

public static void main(String[] args) {
    TreeMap<Student, String> treeMap = new TreeMap<>(new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
            int numName = o1.getName().compareTo(o2.getName());
            int numAge = numName == 0 ? o1.getAge()-o2.getAge() : numName;
            return numAge;
        }
    });
    treeMap.put(new Student("ab",23), "上海");
    treeMap.put(new Student("ab",23), "北京");
    treeMap.put(new Student("ac",26), "北京");
    treeMap.put(new Student("abc",28), "美国");

    System.out.println(treeMap);

}

练习, 字符串 aaabbbccccfgkj 统计字母出现次数

字母在Map里Key 没有, 由存入key,1, 有则存key, value+1

import java.util.HashMap;
import java.util.Map;

public class Demo7_HashMap {
    public static void main(String[] args) {
        HashMap<Character, Integer> hashMap = new HashMap<>();
        String str = "aaabbbbccccd";
        char[] cArray = str.toCharArray();
        for(char c : cArray){
            if( ! hashMap.containsKey(c)){
                hashMap.put(c,1);
            } else {
                hashMap.put(c, hashMap.get(c)+1);
            }
        }
        for(Map.Entry<Character,Integer> ci:hashMap.entrySet()){
            System.out.println(ci.getKey() + "=" + ci.getValue() );
        }
    }
}

练习 HashMap 嵌套 HashMap

import lombok.Getter;
import lombok.Setter;

import java.util.Objects;

public class Student implements Comparable<Student>{
    public Student(){}
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
    @Getter
    @Setter
    private String name;

    @Getter
    @Setter
    private int age;

    @Override
    public String toString() {
        return "Student "+this.name+this.age;
    }

    @Override public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public boolean equals(Object obj) {
        Student s = (Student) obj;
        return this.name == s.name && this.age == s.age;
    }

import com.lizicai.bean.Student;

import java.util.HashMap;
import java.util.Map;

public class Demo8_HashMapHashMap {
    public static void main(String[] args) {
        HashMap<Student, String> hashMap1 = new HashMap<>();
        hashMap1.put(new Student("小明",23), "上海");
        hashMap1.put(new Student("小王",26), "北京");
        hashMap1.put(new Student("莱昂纳多",28), "美国");
        HashMap<Student, String> hashMap2 = new HashMap<>();
        hashMap2.put(new Student("小明",23), "上海");
        hashMap2.put(new Student("小王",26), "北京");
        hashMap2.put(new Student("莱昂纳多",29), "美国");
        HashMap<HashMap<Student,String>,String > hashMap = new HashMap<>();
        hashMap.put(hashMap1,"班级1");
        hashMap.put(hashMap2,"班级2");
        for(Map.Entry<HashMap<Student,String>, String> HH : hashMap.entrySet()){
            for(Map.Entry<Student,String> HHS : HH.getKey().entrySet()){
                System.out.println(HHS.getKey() + HHS.getValue()+HH.getValue());
            }
        }
        System.out.println(hashMap);
    }
}

HashMap 和 Hashtable 区别

共同点

都是双链集合

区别

HashMap 是线程不安全的, 效率高JDK 1.2 版本
Hashtable 是线程安全的, 效率低, JDK 1.0 版本
HashMap 可以存储null 键和 null 值
Hashtable 不可以存储null 键及 null 值

import java.util.HashMap;
import java.util.Hashtable;

public class Demo9_HashMapHashtable {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put(null, 10);
        hashMap.put("a", null);
        System.out.println(hashMap);

        Hashtable<String, Integer> hashtable = new Hashtable<>();
        hashtable.put(null, 10);
        hashtable.put("a", null);
        System.out.println(hashtable);
    }
}

Collections 中的方法

static <T extends Comparable<? super T» void sort(List list) 排序
static int binarySearch(List<? extends Comparable<? super T» list, T key) 二分查找
static <T extends Object & Comparable<? super T» T max(Collection<? extends T> coll) 返回最大值
static void reverse(List list) 反转列表
static void shuffle(List list) list 序列洗牌

private static void Demo5() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("d");
    arrayList.add("a");
    arrayList.add("a");
    arrayList.add("b");
    arrayList.add("c");
    arrayList.add("f");
    System.out.println(arrayList);
    Collections.shuffle(arrayList);
    System.out.println(arrayList);
}

private static void Demo4() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("d");
    arrayList.add("a");
    arrayList.add("a");
    arrayList.add("b");
    arrayList.add("c");
    arrayList.add("f");
    System.out.println(arrayList);
    Collections.reverse(arrayList);
    System.out.println(arrayList);
}

private static void Demo3() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("d");
    arrayList.add("a");
    arrayList.add("a");
    arrayList.add("b");
    arrayList.add("c");
    arrayList.add("f");
    String max = Collections.max(arrayList);
    System.out.println(max);
}

private static void Demo2() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("d");
    arrayList.add("a");
    arrayList.add("a");
    arrayList.add("b");
    arrayList.add("c");
    arrayList.add("a");
    Collections.sort(arrayList);
    System.out.println(arrayList);
    int index = Collections.binarySearch(arrayList, "b");
    System.out.println(index);
    System.out.println(Collections.binarySearch(arrayList,"o"));
}

private static void Demo1() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("d");
    arrayList.add("a");
    arrayList.add("a");
    arrayList.add("b");
    arrayList.add("c");
    arrayList.add("a");
    System.out.println(arrayList);
    Collections.sort(arrayList);
    System.out.println(arrayList);
}

练习, 54 张牌, 每人17张, 剩下3张, 打印每个人牌和底牌

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Demo2_Collections {
    public static void main(String[] args) {
        String[] nu = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
        String[] color = { "♠️",  "♥️", "♦️",  "♣️"};
        ArrayList<String> arrayList = new ArrayList<>();
        for(String nuStr : nu){
            for(String  colorStr : color){
                arrayList.add(nuStr + colorStr);
            }
        }
        arrayList.add("Big King");
        arrayList.add("Small King");
        for(int i=0;i<3;i++){
            Collections.shuffle(arrayList);
        }
        System.out.println(arrayList);
        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<String> list3 = new ArrayList<>();
        ArrayList<String> list4 = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        for(int i=0;i<53;i++){
            if(i >= 50 ){
                list4.add(arrayList.get(i));
            }
            else if( i % 3 == 0){
                list1.add(arrayList.get(i));
            } else if( i % 3 == 1) {
                list2.add(arrayList.get(i));
            } else if( i % 3 ==2 ){
                list3.add(arrayList.get(i));
            }
        }
        System.out.println(list4);
        System.out.println(list1);
        System.out.println(list2);
        System.out.println(list3);
    }
}

练习使用 HashMap 模拟一副牌

用HashMap 的 Key 生成arraylist来洗牌

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeMap;

public class Demo3_Collections {
    public static void main(String[] args) {
        HashMap<Integer, String> poker = new HashMap<>();
        String[] nu = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A","2"};
        String[] color = { "♠️",  "♥️", "♦️",  "♣️"};
        int count = 0;
        ArrayList<Integer> pokerIndex = new ArrayList<>();
        for(String nuStr : nu){
            for(String  colorStr : color){
                poker.put(count, (colorStr + nuStr));
                pokerIndex.add(count);
                count++;
            }
        }
        poker.put(count, "Small King");
        pokerIndex.add(count);
        count++;
        poker.put(count, "Big King");
        pokerIndex.add(count);

        TreeMap<Integer, String> gaojin = new TreeMap<>();
        TreeMap<Integer, String> jp = new TreeMap<>();
        TreeMap<Integer, String> tiger = new TreeMap<>();
        TreeMap<Integer, String> dipai = new TreeMap<>();

        System.out.println(pokerIndex.size());
        Collections.shuffle(pokerIndex);
        System.out.println(pokerIndex);

        for(int i=0;i< pokerIndex.size(); i++){
            int index = pokerIndex.get(i);
            if(i > 50){
                dipai.put( index  , poker.get( index));
            } else if ( i % 3 == 0){
                gaojin.put( index, poker.get(index ));
            } else if (i % 3 == 1){
                jp.put( index , poker.get( index ));
            } else if (i % 3 == 2){
                tiger.put( index, poker.get( index ));
            }
        }
        System.out.println(gaojin);
        System.out.println(jp);
        System.out.println(tiger);
        System.out.println(dipai);

    }
}

? Super E 情况

TreeSet TreeMap 会调用

import lombok.Getter;
import lombok.Setter;

import java.util.Objects;

public class Student implements Comparable<Student>{
    public Student(){}
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
    @Getter
    @Setter
    private String name;

    @Getter
    @Setter
    private int age;

    @Override
    public String toString() {
        return "Student "+this.name+this.age;
    }

    @Override public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public boolean equals(Object obj) {
        Student s = (Student) obj;
        return this.name == s.name && this.age == s.age;
    }

    @Override
    public int compareTo(Student o) {
        int numName = this.name.compareTo(o.name);
        int numAge = numName == 0 ? this.age-o.age : numName;
        return numAge;
    }
}

public class BaseStudent extends Student{
    public BaseStudent(){}
    public BaseStudent(String name, int age){
        super(name, age);
    }
}

import com.lizicai.bean.BaseStudent;
import com.lizicai.bean.Student;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.TreeSet;

public class Demo4_Generic {
    public static void main(String[] args) {
//        Demo1();
        TreeSet<Student> treeSet = new TreeSet<>(new CompareByAge());
        treeSet.add(new Student("小明",22));
        treeSet.add(new Student("小红",22));
        treeSet.add(new Student("小王",22));
        System.out.println(treeSet);


        TreeSet<BaseStudent> treeSet2 = new TreeSet<>(new CompareByAge());
        treeSet2.add(new BaseStudent("小明",22));
        treeSet2.add(new BaseStudent("小红",22));
        treeSet2.add(new BaseStudent("小王",22));
        System.out.println(treeSet2);

    }

    private static void Demo1() {
        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(new Student("小明",22));
        arrayList.add(new Student("小红",22));
        arrayList.add(new Student("小王",22));

        ArrayList<BaseStudent> arrayList2 = new ArrayList<>();
        arrayList2.add(new BaseStudent("小明",22));
        arrayList2.add(new BaseStudent("小红",22));
        arrayList2.add(new BaseStudent("小王",22));

        arrayList.addAll(arrayList2);
        System.out.println(arrayList);
    }
}

class CompareByAge implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        int num = o1.getAge() - o2.getAge();
        int numName = num == 0 ? o1.getName().compareTo(o2.getName()): num;
        return numName;
    }
}

Collection

List 存取有序, 有索引, 可重复

ArrayList
- 底层数组实现的, 线程不安全, 查找修改快, 增删慢
LinkedList
- 底层是链表实现的, 线程不安全, 查找慢, 增删快
Vetor
- 底层数组实现的, 线程安全, 查找修改增删都慢

如果查找修改多用ArrayList, 增和删多用LinkedList, 如果都多用ArrayList

Set 存取无序, 无索引, 不可重复

HashSet
- 底层哈希算法实现的
LinkedHashSet
- 底层是链表, 但是也可以保证元素唯一, 和HashSet 原理一样
TreeSet
- 底层是二叉树实现

开发的时候不需要对存储的元素排序, 大多用HashSet TreeSet 比较的2种方式要记住

Map 存取

HashMap 底层哈希算法, 针对键的
- LinkedHashMap 底层是链表
TreeMap 底层是二叉树实现

双链集合优先考虑TreeMap

Java的Set类 Li.038

Sun, 22 Aug 2021 23:35:31 +0800

Set

无序
不可重复

import java.util.HashSet;

public class Demo1_HashSet {
    public static void main(String[] args) {
        HashSet<String> hs = new HashSet<>();

        boolean b1 = hs.add("a");
        boolean b2 = hs.add("a");
        System.out.println(hs);
        System.out.println(b1+"  "+b2);
        for(String s:hs){
            System.out.println(s);
        }
    }
}

HashSet 的重写hashCode() 方法, hashCode值一致时, 调用equals方法

使用HashSet 存取元素时, 这个元素必须重写 hashCode 和 equals方法

import lombok.Getter;
import lombok.Setter;

import java.util.Objects;

public class Person {
    public Person(){}
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Getter
    @Setter
    private String name;
    @Getter
    @Setter
    private int age;


    @Override
    public String toString(){
        return "Person" + this.getName() + this.getAge();
    }

    @Override
    public boolean equals(Object obj) {
        Person p = (Person) obj;
        return this.getName() == p.getName() && this.getAge() == p.getAge();
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public static int hashCode(Object a[]) {
    if (a == null)
        return 0;

    int result = 1;

    for (Object element : a)
        result = 31 * result + (element == null ? 0 : element.hashCode());

    return result;
}

LinkedHashSet

底层链表实现的
是Set对象中唯一一个保证怎么存就怎么取的集合对象
HashSet的子类, 也是保证元素是唯一的

import java.util.LinkedHashSet;

public class Demo1_LinkedHashSet {
    public static void main(String[] args) {
        LinkedHashSet <String> linkedHashSet = new LinkedHashSet<>();

        linkedHashSet.add("a");
        linkedHashSet.add("a");
        linkedHashSet.add("b");
        linkedHashSet.add("b");
        linkedHashSet.add("b");
        linkedHashSet.add("c");

        System.out.println(linkedHashSet);
    }
}

HashSet 练习, 放入集合10个[1,20]的整数

import java.util.HashSet;
import java.util.Random;

public class Demo1_Test {
    public static void main(String[] args) {
        Random r = new Random();
        HashSet <Integer> hashSet = new HashSet<>();

        while(hashSet.size() < 10 ){
            Integer i = r.nextInt(20) + 1;
            hashSet.add(i);
        }
        System.out.println(hashSet);
    }
}

HashSet 练习, 输入一串字符串, 去掉重复字符

import java.util.HashSet;
import java.util.Scanner;

public class Demo2_Test {
    public static void main(String[] args) {
        HashSet<Character> hs = new HashSet<>();
        Scanner sc = new Scanner(System.in);
        String s = null;
        if(sc.hasNext()){
            s = sc.nextLine();
        }
        char[] charArray= s.toCharArray();

//        for(Character c:charArray){
        for(char c:charArray){
            hs.add(c);
        }
        System.out.println(hs);
    }
}

HashSet 练习, list 去重, 并返回元素list

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;

public class Demo3_Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        list.add("c");

        HashSet <String> hs = new LinkedHashSet<>();
//        deleteCopyElement(list, hs);
        deleteCopyE(list);
//        System.out.println(hs);
        System.out.println(list);
    }
    public static void deleteCopyElement(List<String> list, HashSet<String> hashSet){
        hashSet.addAll(list);
        list.clear();
        list.addAll(hashSet);
    }
    public static void deleteCopyE(List<String> list){
        LinkedHashSet<String> hs = new LinkedHashSet<>();
        hs.addAll(list);
        list.clear();
        list.addAll(hs);
    }
}

TreeSet 集合, 对集合进行排序的, 元素唯一

保证元素唯一
集合排序

import java.util.TreeSet;

public class Demo1_TreeSet {
    public static void main(String[] args) {
        TreeSet <Integer> ts = new TreeSet<>();

        ts.add(1);
        ts.add(1);
        ts.add(2);
        ts.add(2);
        ts.add(3);
        ts.add(3);
        System.out.println(ts);
    }
}

TreeSet , 类实现Comparable接口

compareTo 方法返回0, 则集合中只用一个元素
compareTo 方法返回正数, 集合怎么存怎么取
compareTo 方法返回负数, 集合倒序存储

import lombok.Getter;
import lombok.Setter;

import java.util.Objects;

public class Person implements Comparable <Person>{
    public Person(){}
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Getter
    @Setter
    private String name;
    @Getter
    @Setter
    private int age;


    @Override
    public String toString(){
        return "Person" + this.getName() + this.getAge();
    }



    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Person)) {
            return false;
        }
        Person person = (Person) o;
        return getAge() == person.getAge() && Objects.equals(getName(), person.getName());
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public int compareTo(Person p) {
        int num = this.age - p.age;
        return num == 0 ? this.name.compareTo(p.name) : num;
    }
}

public class Demo1_TreeSet {
    public static void main(String[] args) {
        TreeSet<Person> ts = new TreeSet<>();
        ts.add(new Person("小明", 20));
        ts.add(new Person("小红", 19));
        ts.add(new Person("小张", 21));
        ts.add(new Person("小张", 21));

        System.out.println(ts);
    }
}

TreeSet 如果使用Person 的name排序, 则需要实现Compareable 接口, compareTo方法

@Override
public int compareTo(Person p) {
    int num = this.name.compareTo(p.name);
    return num == 0 ? this.age-p.age : num;
}

public class Demo1_TreeSet {
    public static void main(String[] args) {
        TreeSet<Person> ts = new TreeSet<>();
        ts.add(new Person("a", 20));
        ts.add(new Person("a", 19));
        ts.add(new Person("ab", 19));
        ts.add(new Person("ba", 21));
        ts.add(new Person("ca", 21));

        System.out.println(ts);
    }
}

TreeSet 使用Person 的name长度比较

@Override
public int compareTo(Person p){
    int length = this.name.length()- p.name.length();
    int num = length == 0 ? this.name.compareTo(p.name) : length;
    return num == 0 ? this.age - p.age : num;
}

TreeSet 实现Comparator接口, 在创建TreeSet时调用

自动定义String 长度作为比较

class Compare implements Comparator<String>{
    @Override
    public int compare(String o1, String o2) {
        int length = o1.length() - o2.length();
        int num =  length == 0 ? o1.compareTo(o2) : length;
        return num;
    }
}

public class Demo4_TreeSet {
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<>(new Compare());
        ts.add("asdfsdf");
        ts.add("z");
        System.out.println(ts);
    }

}

练习, ArrayList 重复无序的数据, 如何按字典排序, 且不可去除重复数据

import java.util.ArrayList;
import java.util.Comparator;
import java.util.TreeSet;

public class Demo5_TreeSet {
    public static void main(String[] args) {
        ArrayList<String> aList = new ArrayList<>();
        aList.add("aaa");
        aList.add("aaa");
        aList.add("aaa");
        aList.add("bbb");
        aList.add("bbb");
        aList.add("bbb");
        aList.add("bbb");
        aList.add("aaa");
        aList.add("aaa");
        aList.add("zzz");
        aList.add("zzz");
        aList.add("zzz");
        sortArrayList(aList);
        System.out.println(aList);

    }
    public static void sortArrayList(ArrayList<String> list){
       // 实际Comparator
       // list添加到tree(new comparator)中
       // 清空list
       // list.addAll(TreeSet)
        TreeSet<String> ts = new TreeSet<>(new StrComparator());
        ts.addAll(list);
        list.clear();
        list.addAll(ts);
    }
}
class StrComparator implements Comparator<String> {
    @Override
    public int compare(String o1, String o2) {
        int num = o1.compareTo(o2);
        if(0 == num){
            num ++;
        }
        return num;
    }
}

练习, 输入字符hello 输出ehllo

import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class Demo6_TreeSet {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = null;
        if(sc.hasNext()){
            s = sc.nextLine();
        }
        char[] chaArray = s.toCharArray();
//        Arrays.sort(chaArray);
//        System.out.println(chaArray);
        TreeSet<Character> ts = new TreeSet<>(new Comparator<Character>() {
            @Override
            public int compare(Character o1, Character o2) {
                int num = o1.compareTo(o2);
                return num == 0? 1 :num;
            }
        });
        for(Character c:chaArray){
            ts.add(c);
        }
        for(Character c:ts){
            System.out.print(c);
        }
    }
}

练习, 输入数字并倒序

输入quit 退出

import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class Demo7_TreeSet {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                int num = o2.compareTo(o1);
                return num == 0 ? 1 :num ;
            }
        });
        while (sc.hasNext()){
            String s = sc.next();
            if( "quit".equals(s)){
                break;
            } else{
                ts.add(Integer.parseInt(s));
            }
        }
        for(Integer i:ts){
            System.out.print(i+" ");
        }
    }
}

练习

录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩) 按总成绩从高到低输入到控制台

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@AllArgsConstructor
@NoArgsConstructor
public class Student implements Comparable<Student>{
    @Getter
    @Setter
    private String name;
    @Getter
    @Setter
    private int motherTongue;
    @Getter
    @Setter
    private int math;
    @Getter
    @Setter
    private int english;

    @Override
    public int compareTo(Student o) {
        int num =  (o.motherTongue + o.math + o.english) - (this.motherTongue + this.math + this.english);
        int num2 = num == 0 ? o.motherTongue - this.motherTongue : num;
        int num3 = num2 == 0 ? o.math - this.math : num2;
        int num4 = num3 == 0 ? o.english - this.english : num3;
        int num5 = num4 == 0 ? o.name.compareTo(this.name) : num4 ;
        if (0 == num5){
            num5 = -1;
        }
        return num5;
    }

    @Override
    public String toString() {
        return "Student."+this.name +".语文"+this.motherTongue+".数学"+this.math+".英语" + this.english;

    }
}

import com.lizicai.bean.Student;

import java.util.Scanner;
import java.util.TreeSet;

public class Demo8_TreeSet {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        TreeSet<Student> ts = new TreeSet<>();
        for(int i=0; i<5;i++){
            String str = null;
            if(sc.hasNext()){
                str = sc.nextLine();
            }
            String[] strArray = str.split(",");
            ts.add(new Student(strArray[0],
                    Integer.parseInt(strArray[1]),
                    Integer.parseInt(strArray[2]),
                    Integer.parseInt(strArray[3])));
        }
        System.out.println(ts);
    }
}

Java的List类 Li.037

Fri, 20 Aug 2021 17:17:58 +0800

List 练习Person 集合去重

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private String name;
    private int age;

    @Override
    public boolean equals(Object obj) {
        Person p = (Person) obj;
        boolean d = false;
        if(this.getAge() == p.getAge() && this.getName() == p.getName()){
            d = true;
        } else{
            d = false;
        }
        return d;
    }
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Demo2_ArrayList {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Person("小明", 23));
        list.add(new Person("小明", 23));
        list.add(new Person("小红", 22));
        list.add(new Person("小王", 25));

        List list2 = new ArrayList();
        deleteMu(list, list2);
        System.out.println(list2);

    }
    public static void deleteMu(List srcList, List destList){
        Iterator iTsrc = srcList.iterator();
        while (iTsrc.hasNext()){
            Person p = (Person) iTsrc.next();
            if( !destList.contains(p) ){

                destList.add(p);
            }
        }
        return ;
    }
}

LinkedList 方法

void addFirst(E e) void addLast(E e) 在头增加或在尾增加
public E getFirst() public E getLast() 获取第1个或最后1个
public E removeFirst() public E removeLast() 删除第1个或最后1个
public E get(int index) 获取指定位置的元素

import java.util.LinkedList;

public class Demo1_LinkedList {
    public static void main(String[] args) {
        LinkedList ll = new LinkedList();
        ll.add("a");
        ll.add("b");
        ll.add("c");
        ll.add("d");

        ll.addFirst(0);
        ll.addLast(10);
        System.out.println(ll);

        System.out.println(ll.getFirst());
        System.out.println(ll.getLast());

        ll.removeFirst();
        System.out.println(ll);
        ll.removeLast();
        System.out.println(ll);

        System.out.println(ll.get(0));
    }
}

LinkedList 模拟栈

import lombok.Data;

import java.util.LinkedList;

@Data
public class Stank {
    private LinkedList ll = new LinkedList();

    public  void in(Object obj){
        ll.addLast(obj);
    }
    public void out(){
        ll.removeLast();
    }
    public void outAll(){
        while (! ll.isEmpty()){
            ll.removeLast();
        }
    }
    public boolean isEmpty(){
        if(ll.isEmpty()){
            return true;
        }
        return false;
    }
}


import com.lizicai.bean.Stank;

public class Demo3_LinkedList {
    public static void main(String[] args) {
        Stank s = new Stank();
        s.in("a");
        s.in("b");
        s.in("c");
        s.out();
        System.out.println(s.getLl());
        s.outAll();
        System.out.println(s.getLl());
    }
}

泛型 generic

泛型的好处

提高安全性, 把运行的错误转移到编译时校验
省去强转的麻烦

前后泛型一致, 或者后面泛型是前端泛型的子类

public class Demo1_Generic {
    public static void main(String[] args) {
        ArrayList <Person> list = new ArrayList<>();
        list.add(new Person("小红", 23));
        list.add(new Person("小明", 23));

        ListIterator <Person> it = list.listIterator();
        while ( it.hasNext()){
            Person p = it.next();
            System.out.println(p.getName() + p.getAge());
        }
    }
}

类的泛型

在类首行指定处理的引用数据类型

public class SePersion <E>{
    private E e;

    public E getP() {
        return e;
    }

    public void setP(E p) {
        this.e = p;
    }
}


import com.lizicai.bean.Person;
import com.lizicai.bean.SePersion;

public class Demo3_Generic {

    public static void main(String[] args) {
        SePersion<Person> s = new SePersion();
//        s.setP("kdfj");
        s.setP(new Person("小明", 23));
        System.out.println(s.getP());

        SePersion d = new SePersion();
        d.setP("dk");
        d.setP(new Person());
        System.out.println(d.getP());
    }
}

方法泛型

方法泛型和类的泛型一至
也可以不一致, 在使用方法时指定泛型
静态方法必须申明自己的泛型

public class SePersion <E>{
    private E e;

    public E getP() {
        return e;
    }

    public void setP(E e) {
        this.e = e;
    }
    public <T> void show(T t){
        System.out.println(t);
    }
    public static<Q> void print(Q q){
        System.out.println(q);
    }
}

泛型高级之通配符

泛型通配符, 如果没有明确, 那么就是Object 及任意Java类
? extends E ?是E的子类, 向下限定示例是这个
? super E ? 是E的父类, 向下限定

public class Person {
    private String name;
    private int age;
    public  Person(){}
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        Person p = (Person) obj;
        boolean d = false;
        if(this.getAge() == p.getAge() && this.getName() == p.getName()){
            d = true;
        } else{
            d = false;
        }
        return d;
    }
    @Override
    public String toString(){
        return this.getName() + this.getAge();
    }
}

public class Student extends Person{
    private String name;
    private int age;
    public Student(){ }
    public Student(String name, int age){
        super(name,age);
    }
}

public class Demo5_Generic {
    public static void main(String[] args) {
        ArrayList <Person> arrayList = new ArrayList<>();
        arrayList.add(new Person("小明", 23));
        arrayList.add(new Person("小红", 22));

        ArrayList <Student> arrayList2 = new ArrayList<>();
        arrayList2.add(new Student("小张", 25));
        arrayList2.add(new Student("小美", 26));

        arrayList.addAll(arrayList2);

        System.out.println(arrayList);

        Person p = new Student("test",20);
        System.out.println(p.toString());

    }
}

增加for循环

底层依赖 iterator 迭代器

import com.lizicai.bean.Person;

import java.util.ArrayList;

public class Demo6_Generic {
    public static void main(String[] args) {
        ArrayList <Person> arrayList = new ArrayList<>();
        arrayList.add(new Person("小红", 22));
        arrayList.add(new Person("小明", 23));
        arrayList.add(new Person("小张", 25));

        for(Person p:arrayList){
            System.out.println(p);
        }

        int [] arr = {1, 2, 3 ,4, 5};
        for(int i:arr){
            System.out.print(i);
        }
    }
}

三种迭代

普通for循环, 可以删除, 索引-1
迭代器, 可以删除, 必须使用迭代器中的remove() 方法, 否则出现并发修改异常
增加for循环, 不可删除

import java.util.ArrayList;
import java.util.ListIterator;

public class Demo7_Generic {
    public static void main(String[] args) {
        ArrayList <String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("b");
        arrayList.add("c");
        for (int i = 0; i < arrayList.size(); i++) {
            if("b".equals(arrayList.get(i))){
                arrayList.remove(i);
                i--;
            }
        }

        ArrayList<String> arrayList2 = new ArrayList<>();
        arrayList2.add("a");
        arrayList2.add("b");
        arrayList2.add("b");
        arrayList2.add("c");
        ListIterator<String > it = arrayList2.listIterator();
        while (it.hasNext()){
            if( "b".equals(it.next())){
//                arrayList2.remove("b");
                it.remove();
            }
        }
        System.out.println(arrayList);

        System.out.println(arrayList2);

        for (ListIterator<String> it2 = arrayList2.listIterator(); it2.hasNext();){

            System.out.println(it2.next());
        }

    }
}

静态导入, 一般不用

import java.util.Arrays.sort

可变参数

定义的时候不知道定义多少个
可变参数其实是一个数组
如果一个方法有多个参数, 可变参数必须是最后一个

public class Demo1_ChangeableArgs {
    public static void main(String[] args) {
       int[] arr = {5, 2, 3, 4, 5};
//       print(arr);
//       print(1,2,3,4,5,6);

//        for(int i=0;i<arr.length;i++){
//            System.out.println(arr[i]);
//        }
        pp(arr);

    }
//    public static void print(int[] arr){
//        for(int i=0;i<arr.length;i++){
//            System.out.println(arr[i]);
//        }
//    }

    public static void print(int ... arr){
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

    public static void pp(int [] arr){
        for(int i:arr){
            System.out.println(arr[i]);
        }
    }
}

数组转集合

基本数据类型数组转成集合, 只会把数组的地址作为元素转到集合中
要想基本数据转成集合, 必须是引用类型 int -> Integer boolean Boolean

import java.util.Arrays;
import java.util.List;
public class Demo8_Generic {
    public static void main(String[] args) {
        String [] arr = {"a", "b", "c"};
        List<String> arrayList = Arrays.asList(arr);
//        arrayList.add("d");
        System.out.println(arrayList);

        Integer [] arr2 = {new Integer(1),new Integer(2),new Integer(3)};
        List a = Arrays.asList(arr2);
        System.out.println(a);

    }
}

集合转数组

如果集合size大于等于数组, 则转换后, 数组长度 = 集合长度
集合size小于数组, 转换后, 数组长度还是原数组长度

import java.util.ArrayList;

public class Demo9_Generic {
    public static void main(String[] args) {
        ArrayList<String>  arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");

        String[] arr = arrayList.toArray(new String[2]);
        String[] arr2 = arrayList.toArray(new String[4]);
        System.out.println(arr.length);
        System.out.println(arr2.length);
        for(String s:arr){
            System.out.print(s);
        }
    }
}

集合嵌套之ArrayList嵌套ArrayList

import java.util.ArrayList;

public class Demo10_Generic {
    public static void main(String[] args) {
        ArrayList <ArrayList<Person>> arrayList = new ArrayList<>();
        ArrayList<Person> cls1 = new ArrayList<>();
        ArrayList<Person> cls2 = new ArrayList<>();

        cls1.add(new Person("小明", 20));
        cls1.add(new Person("小红", 19));
        cls1.add(new Person("小张", 21));

        cls2.add(new Person("小丽", 21));
        cls2.add(new Person("小李", 22));
        cls2.add(new Person("小王", 23));

        arrayList.add(cls1);
        arrayList.add(cls2);

        for(ArrayList<Person> s:arrayList){
            for(Person p:s){
                System.out.println(p);
            }
        }
    }
}

Java的Collection集合一 Li.036

Thu, 19 Aug 2021 16:41:04 +0800

Collection 和数组区别

数组可以存储基本数据类型, 也可以存储引用数据类型
集合可以存储引用数据类型, 也能存基本数据类型, 存储时会自动装箱
数组的长度固定, 不可以自由增加
集合长度可变, 可以自由增加

List Set 集合

List

有序集合, 存取位置一致
有索引
可存储重复数据

Set

无序集合, 存取位置不一致
无索引
不可存储重复数据

List 体系 ArrayList LinkedList Vector

ArrayList

底层是数组, 查询快, 增删慢
线程不安全, 效率高

LinkedList

链表实现, 查询慢, 增删快
线程不安全, 效率高

Vection

数组实现, 查询快, 增删慢
线程安全, 效率低

Set 体系 HashSet TreeSet

HashSet

哈希算法

TreeSet

二叉树算法

ArrayList 的

boolean add(E e) 方法一直返回true, Set 集合存取重复元素时, 则返回false
boolean remove(Object o) 一次删除一个对象
int size() 打印集合对象数
void clear() 清空集合
boolean isEmpty() 判断集合是否为空

public class Demo2_Collection {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        boolean b1 = collection.add("abc");
        boolean b2 = collection.add(true);
        boolean b3 = collection.add(100);
        boolean b4 = collection.add(new Student("小红",18));
        boolean b5 = collection.add("abc");
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b5);
        System.out.println(collection);

        System.out.println(collection.contains("abc"));
        collection.remove("abc");
        System.out.println(collection);
        collection.remove("abc");
        System.out.println(collection.size());
        System.out.println(collection);
        System.out.println(collection.isEmpty());
        collection.clear();
        System.out.println(collection.isEmpty());
        System.out.println(collection);
    }
}

Object[] toArray() 集合转换成数组

import com.lizicai.bean.Student;
import java.util.ArrayList;
import java.util.Collection;

public class Demo3_Collection {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c .add( new Student("小明", 24));
        c .add( new Student("小红", 22));
        c .add( new Student("小张", 30));
        Object [] oArray = c.toArray();
        for(Object o:oArray){
            if( o instanceof Student){
                Student s = (Student) o;
                System.out.println(s.getName()+s.getAge());
            } else{
                System.out.println(o);
            }
        }
    }
}

List 中带有All的方法

boolean addAll(Collection<? extends E> c) 添加另一个集合
boolean removeAll(Collection c) 移除集合中所有与C集合一样的元素
boolean containsAll(Collection c) 返回结果c集合全部是调用集合内元素的判断结果
boolean retainAll(Collection c) 调用集合和c集合取交集, 调用集合改变则是true, 没改是false

private static void Demo4() {
    Collection c = new ArrayList();
    c.add("a");
    c.add("b");
    c.add("c");
    Collection c2 = new ArrayList();
    c2.add("a");
    c2.add("b");
    System.out.println(c.retainAll(c2));
    System.out.println(c);
}

private static void Demo3() {
    Collection c = new ArrayList();
    c.add("a");
    c.add("b");
    c.add("b");
    c.add("c");
    Collection c2 = new ArrayList();
    c2.add("a");
    c2.add("b");
    c2.add("c");
    System.out.println(c.containsAll(c2));
    System.out.println(c);
    System.out.println(c2);
}

private static void Demo2() {
    Collection c = new ArrayList();
    c.add("a");
    c.add("b");
    c.add("b");
    c.add("c");
    Collection c2 = new ArrayList();
    c2.add("a");
    c2.add("b");
    c2.add("cc");
    c.removeAll(c2);
    System.out.println(c);
}

private static void Demo1() {
    Collection c = new ArrayList();
    c.add("a");
    c.add("b");
    c.add("c");
    Collection c2 = new ArrayList();
    c2.add("aa");
    c2.add("bb");
    c2.add("cc");

    c.addAll(c2);
    c2.add(c);
    System.out.println(c);
    System.out.println(c2);
}

集合的迭代器遍历

import com.lizicai.bean.Student;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo1_Iterator {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(new Student("小明", 24));
        c.add(new Student("小红", 22));
        c.add(new Student("小张", 30));
        Iterator it = c.iterator();
        while (it.hasNext()){
            Object obj = it.next();
            if( obj instanceof Student){
                Student s = (Student)obj;
                System.out.println(s.getName()+s.getAge());
            } else {
                System.out.println(obj);
            }
        }
    }
}

List 集合

void add(int index, E element)
E remove(int index)
E get(int index)
E set(int index, E element)

import java.util.ArrayList;
import java.util.List;

public class Demo1_List {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add(0,"d");
        System.out.println(list);

        list.remove(0);
        System.out.println(list);

        list.set(2,"w");
        System.out.println(list);

        System.out.println(list.get(2));
    }
}

List 遍历的2种方式

for循环
iterator迭代器

public class Demo2_List {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

List 的 ListIterator 可以在遍历的时候添加元素, List不能在遍历的时候添加元素

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Demo3_List {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("ab");
        list.add("abc");
        list.add("Hello");

//        Iterator li = list.iterator();
//        while (li.hasNext()){
//            String s = (String)li.next();
//            if("Hello".equals(s)){
//                list.add("World");
//            }
//            System.out.println(s);
//        }

        ListIterator li = list.listIterator();
        while (li.hasNext()){
            String s = (String)li.next();
            if("Hello".equals(s)){
                li.add("World");
            }
        }
        System.out.println(list);
    }
}

Vector

import java.util.Enumeration;
import java.util.Vector;
public class Demo1_Vector {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.addElement("a");
        v.addElement("b");
        v.addElement("c");
        v.addElement("d");

        Enumeration en = v.elements();
        while (en.hasMoreElements()){
            System.out.println(en.nextElement());
        }
    }
}

Java的正则表达式 Li.035

Mon, 16 Aug 2021 16:45:01 +0800

Java 的正则表达式Regex

java.util.regex.Pattern 有正则表达示例

/*
[abc]	a, b, or c (simple class)   abc中任意一个字符
[^abc]	Any character except a, b, or c (negation)  非abc的一个字符
[a-zA-Z]	a through z or A through Z, inclusive (range)  匹配a-z A-Z 大小写字符
[a-d[m-p]]	a through d, or m through p: [a-dm-p] (union)  匹配a-d 和 匹配 m-p 字符, 匹配则true
[a-z&&[def]]	d, e, or f (intersection)  匹配def 与 a-z的并集是 def
[a-z&&[^bc]]	a through z, except for b and c: [ad-z] (subtraction), 非bc 和 a-z取并集(匹配a d-z字符)
[a-z&&[^m-p]]	a through z, and not m through p: [a-lq-z](subtraction), 非m-p字符与a-z取并集, 并集是a-l和q-z
 */

private static void Demo7() {
    String regex = "[a-z&&[^m-p]]";
    System.out.println("a".matches(regex));
    System.out.println("n".matches(regex));
}

private static void Demo6() {
    String regex = "[a-z&&[^bc]]";
    System.out.println("a".matches(regex));
    System.out.println("b".matches(regex));
}

private static void Demo5() {
    String regex = "[a-z&&[def]]";
    System.out.println("m".matches(regex));
    System.out.println("a".matches(regex));
    System.out.println("d".matches(regex));
}

private static void Demo4() {
    String regex = "[a-d[x-z]]";
    System.out.println("m".matches(regex));
    System.out.println("a".matches(regex));
    System.out.println("x".matches(regex));
}

private static void Demo3() {
    String regex = "[a-zA-Z]";
    System.out.println("a".matches(regex));
    System.out.println("*".matches(regex));
}

private static void Demo2() {
    String regex = "[^abc]";
    System.out.println("a".matches(regex));
    System.out.println("d".matches(regex));
    System.out.println("10".matches(regex));
}

private static void Demo1() {
    String regex = "[abc]";
    System.out.println("a".matches(regex));
    System.out.println("d".matches(regex));
}

正则预先定义的字符

public class Demo4_Regex {
    public static void main(String[] args) {
       /*
         .	Any character (may or may not match line terminators)  匹配任何字符
        \d	A digit: [0-9]    0-9字符, 其他字符则false
        \D	A non-digit: [^0-9]  非 0-9 字符, 0-9字符则false
        \h	A horizontal whitespace character: [ \t\xA0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000]  水平空白字符
        \H	A non-horizontal whitespace character: [^\h]   非水平空白字符
        \s	A whitespace character: [ \t\n\x0B\f\r]  空白字符
        \S	A non-whitespace character: [^\s]  非空白字符
        \v	A vertical whitespace character: [\n\x0B\f\r\x85\u2028\u2029]  垂直空白字符
        \V	A non-vertical whitespace character: [^\v]   非垂直空白字符
        \w	A word character: [a-zA-Z_0-9] 大小写 数字 下划线
        \W	A non-word character: [^\w]  除大小写 数字 下划线 以外字符
        */
    }

    private static void Demo5() {
        // 字符 \w a-zA-Z0-9_ \W, 除去a-zA-Z0-9_的字符
        String regex = "\\w";
        System.out.println("s".matches(regex));
        System.out.println("_".matches(regex));
        System.out.println("0".matches(regex));
        System.out.println("&".matches(regex));

        String regex2 = "\\W";
        System.out.println("s".matches(regex2));
        System.out.println("_".matches(regex2));
        System.out.println("0".matches(regex2));
        System.out.println("&".matches(regex2));
    }

    private static void Demo4() {
        String regex = "\\v";
        System.out.println(" ".matches(regex));
        System.out.println("\t".matches(regex));
        System.out.println("\n".matches(regex));
        System.out.println("a".matches(regex));

        String regex2 = "\\V";
        System.out.println(" ".matches(regex2));
        System.out.println("\t".matches(regex2));
        System.out.println("\n".matches(regex2));
        System.out.println("a".matches(regex2));
    }

    private static void Demo3() {
        String regex = "\\s";
        System.out.println(" ".matches(regex));
        System.out.println("\t".matches(regex));
        System.out.println("\n".matches(regex));
        System.out.println("a".matches(regex));

        String regex2 = "\\S";
        System.out.println(" ".matches(regex2));
        System.out.println("\t".matches(regex2));
        System.out.println("\n".matches(regex2));
        System.out.println("a".matches(regex2));
    }

    private static void Demo2() {
        String regex = "\\h";
        String regex2 = "\\H";
        System.out.println("a".matches(regex));
        System.out.println(" ".matches(regex));
        System.out.println("\t".matches(regex));
        System.out.println("\n".matches(regex));

        System.out.println("a".matches(regex2));
        System.out.println(" ".matches(regex2));
        System.out.println("\t".matches(regex2));
        System.out.println("\n".matches(regex2));
    }


    private static void Demo1() {
        String regex = "\\d";
        System.out.println("a".matches(regex));
        System.out.println("9".matches(regex));

        String regex2 = "\\D";
        System.out.println("a".matches(regex2));
        System.out.println("9".matches(regex2));
    }
    private static void Demo() {
        String regex = ".";
        System.out.println("a".matches(regex));
        System.out.println("%".matches(regex));
        System.out.println("9".matches(regex));
    }
}

正则匹配出现次数

public class Demo5_Regex {
    public static void main(String[] args) {
        /*
        X?	X, once or not at all  X出现一次或一次也没有, 但是不能出现其他内容
        X*	X, zero or more times  X出现0次或>0次, 但是不能出现其它内容
        X+	X, one or more times   X出现1次或>1次, 但是不能出现其它内容
        X{n}	X, exactly n times X准确出现n次, 不多不少, 但是不能出现其它内容
        X{n,}	X, at least n times X出现次数至少n次, 但是不能出现其它内容
        X{n,m}	X, at least n but not more than m times  X出现次数 至少n次, 不超过m次, 记[n, m)次
        */
    }

    private static void Demo6() {
        String regex = "[abc]{2,4}";
        System.out.println("a".matches(regex));
        System.out.println("ab".matches(regex));
        System.out.println("aba".matches(regex));
        System.out.println("abca".matches(regex));
        System.out.println("abcabc".matches(regex));
        System.out.println(" ".matches(regex));
    }

    private static void Demo5() {
        String regex = "[abc]{5,}";
        System.out.println("abca".matches(regex));
        System.out.println("abcab".matches(regex));
        System.out.println("abcabc".matches(regex));
        System.out.println("dkfjkf".matches(regex));
    }

    private static void Demo4() {
        String regex = "[abc]{5}";
        System.out.println("abca".matches(regex));
        System.out.println("abccc".matches(regex));
        System.out.println("abcabc".matches(regex));
        System.out.println("abccd".matches(regex));
        System.out.println("d".matches(regex));
        System.out.println(" ".matches(regex));
    }

    private static void Demo3() {
        String regex = "[abc]+";
        System.out.println("a".matches(regex));
        System.out.println("abc".matches(regex));
        System.out.println("abcabccc".matches(regex));
        System.out.println("abcd".matches(regex));
        System.out.println("".matches(regex));
        System.out.println("d".matches(regex));
    }

    private static void Demo2() {
        String regex = "[abc]*";
        System.out.println("".matches(regex));
        System.out.println("a".matches(regex));
        System.out.println("b".matches(regex));
        System.out.println("bb".matches(regex));
        System.out.println("abc".matches(regex));
        System.out.println(" ".matches(regex));
        System.out.println("s".matches(regex));
    }

    private static void Demo1() {
        String regex = "[abc]?";
        System.out.println("".matches(regex));
        System.out.println("a".matches(regex));
        System.out.println("b".matches(regex));
        System.out.println(" ".matches(regex));
        System.out.println("bb".matches(regex));
        System.out.println("s".matches(regex));
    }
}

String 中的 split 方法

String[] split(String regex) 匹配正则分隔成字符串数组

// 空格或问号出现1次或以上, 分隔
public class Demo6_Regex {
    public static void main(String[] args) {
        String str = "What is a youth?";
        String regex = "[\\s\\?]+";
        String [] strArray = str.split(regex);
        for(String s:strArray){
            System.out.println(s);
        }
    }
}

练习字符串的数组, 经过排序后, 再转换成字符串

字符串, 分隔成字符串组
字符串组转换为数组
数组排序
数组重新转换为字符串

public class Demo1_Split {
    public static void main(String[] args) {
        String str = "1 10 2 30 100 40";
        String regex = "[\\s]+";
        String [] strArray = str.split(regex);
        int [] a = new int[strArray.length];
        for(int i=0;i<strArray.length;i++){
            a[i]  =  Integer.parseInt(strArray[i]);
        }
        StringBuffer sb = new StringBuffer();
        Arrays.sort(a);
        if(a.length <1){
            sb = sb.append("{}");
        } else{
            sb.append("{");
            for (int i=0;i<a.length;i++){
                if(i == a.length-1){
                    sb.append(a[i] + "}");
                    break;
                }
                sb.append(a[i] + " ");
            }
        }
        System.out.println(sb);
    }
}

正则匹配, 替换字符

public class Demo2_Replace {
    public static void main(String[] args) {
        String str = "What2is2a233youth?";
        String regex = "[\\d]";
        String res = str.replaceAll(regex,"");
        System.out.println(res);

        String regex2 = "[\\d]";
        String res2 = str.replaceAll(regex2," ");
        System.out.println(res2);

        String regex3 = "[\\d]+";
        String res3 = str.replaceAll(regex3," ");
        System.out.println(res3);
    }
}

正则匹配, 组捕获

((A)(B(C))) , 组是以左括号为一组, 所有共有 4 组

((A)(B(C)))
(A)
(B(C))
(C)

正则匹配, 组的练习

public class Demo4_Replace {
    public static void main(String[] args) {
//        Demo1();
        String str = "我...我...我...我....想想........学编...编...程....程...程程..";
        String regex = "[\\.]+";
        String str2 = str.replaceAll(regex, "");
        System.out.println(str2);

        String regex2 = "(.)\\1+";
        String str3 = str2.replaceAll(regex2, "$1");
        System.out.println(str3);
    }

    private static void Demo1() {
        String str = "abchhhhkdjflllljkklqqqq";
        String regex = "(.)\\1+";
        String[] strArray = str.split(regex);
        for(String s:strArray){
            System.out.println(s);
        }
    }
}

正则匹配, Pattern 和 Matcher, 练习获取手机号

考虑手机号第2位一直在增加, 以1开头11位即认为正确手机号

public static void main(String[] args) {
    String str = "我用过的手机号12310001000, 上一个手机号是12310001001, 目前在用的12310001002";
    String regex = "[1][\\d]{10}";
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher(str);
    while (m.find()){
        System.out.println(m.group());
    }
}

Math 类

public class Demo1_Math {
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.abs(-120));
        // 向上取整 (0,1]
        System.out.println(Math.ceil(23.8));
        System.out.println(Math.ceil(23.1));
        // 向下取整 [0,1)
        System.out.println(Math.floor(23.8));
        System.out.println(Math.floor(24.0));
        System.out.println(Math.max(23,30));
        System.out.println(Math.pow(3,3));
        // 包含 [0.0,1.0)
        System.out.println(Math.random());
        System.out.println(Math.sqrt(2));
    }
}

Random 随机数

Random 是伪随机数, 生成的随机数由随机因子决定的
nextInt(100) 可以生成[0,100) 的随机整数

import java.util.Random;
public class Demo1_Random {
    public static void main(String[] args) {
        Random r = new Random();
        for(int i=0;i<10;i++){
            int a = r.nextInt(100);
            System.out.println(a);
        }

        Random r2 = new Random(1000);
        int a1 = r2.nextInt();
        int a2 = r2.nextInt();
        System.out.println(a1);
        System.out.println(a2);
        // 执行多少次 a1 和 a2 固定
    }
}

System 类

System.in 输入流, Scanner 录收键盘
System.out 输出控制台
System.gc() 垃圾回收
System.currentTimeMillis() 到1971年的毫秒, 2次时间差就能知道程序运行时间
exit() 退出 0 正常终止, 非0 异常终止
arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 数组复制, int str 对象等都可复制

public class Demo1_System {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        System.out.println("jkdjf");
        System.out.println(System.currentTimeMillis());
        long start = System.currentTimeMillis();
        for(int i=0;i<10000000;i++){
            System.out.print("");
            StringBuffer sf = new StringBuffer();
        }
        long end = System.currentTimeMillis();

        System.out.println(end-start);
        for(int i=0;i<10;i++){
            new Test();
            System.gc();
        }
        int [] src = {1, 2, 3, 4, 5};
        int [] dest = new int[8];
        System.arraycopy(src, 0, dest,0,src.length);
        for(int i:dest){
            System.out.println(i);
        }
    }
}
class Test{
    Test(){}
    @Override
    public void finalize(){
        System.out.println("垃圾回收");
    }
}

BigInteger 类

import java.math.BigInteger;

public class Demo1_BigInteger {
    public static void main(String[] args) {
        BigInteger bi1 = new BigInteger("100");
        BigInteger bi2 = new BigInteger("3");
        System.out.println(bi1.add(bi2));
        System.out.println(bi1.subtract(bi2));
        System.out.println(bi1.multiply(bi2));
        System.out.println(bi1.divide(bi2));
        BigInteger [] bArray;
        bArray = bi1.divideAndRemainder(bi2);
        for(BigInteger b:bArray){
            System.out.println(b);
        }
    }
}

BigDecimal, 金融运算使用

static BigDecimal valueOf(double val) 由double 转为 BigDecimal
构造函数时BigDecimal(String val), string 转为 BigDecimal

public class Demo1_BigDecimal {
    public static void main(String[] args) {

        System.out.println(2.0 - 1.1 );

        BigDecimal bd1 = new BigDecimal(2.0);
        BigDecimal bd2 = new BigDecimal(1.1);
        System.out.println(bd1.subtract(bd2));

        BigDecimal bd3 = new BigDecimal("2.0");
        BigDecimal bd4 = new BigDecimal("1.1");
        System.out.println(bd3.subtract(bd4));

        BigDecimal bd5 = BigDecimal.valueOf(2.0);
        BigDecimal bd6 = BigDecimal.valueOf(1.1);
        System.out.println(bd5.subtract(bd6));
    }
}

Date 类

System.currentTimeMillis date.getTime() 都是与GMT 1970 01 01 00:00:00 的毫秒值

public class Demo1_Date {
    public static void main(String[] args) {
//        Demo1();
        Date date = new Date();
        System.out.println(date.getTime());
        System.out.println(System.currentTimeMillis());

        date.setTime(2000);
        System.out.println(date);
    }

    private static void Demo1() {
        Date date = new Date();
        System.out.println(date);
        Date date2 = new Date(0);
        System.out.println(date2);
    }
}

SimpleDateFormat

Date 特定格式输出
字符串转为Date

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo1_DateFormat {
    public static void main(String[] args) throws ParseException {
//        Demo1();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
        String strDate = "2021年08月18日 23:44:59 星期三";
        Date date = sdf.parse(strDate);
        System.out.println(date);
    }

    private static void Demo1() {
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
        System.out.println(sdf.format(date));
    }
}

SimpleDateFormat 练习, 从生日到现在多少天了

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo2_DateFormat {
    public static void main(String[] args) throws ParseException {
        String strDate = "1991-01-01";
        Date date = new Date();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthday = sdf.parse(strDate);

        long days = date.getTime() - birthday.getTime();

        System.out.println(days/1000/3600/24);
    }
}

Calendar 类

Calendar 的获取月份时的0对应1月, 7 对应8月
Calendar 获取的1对应的是星期天, DAY_OF_WEEK
add(int field, int amount) 给年月日时分秒增减
set(int field, int value) 给年月日时分秒设置数值
set(int year, int month, int date) 设置年月日

import java.text.SimpleDateFormat;
import java.util.Calendar;

public class Demo1_Calendar {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        String month = setTwoNu(cal.get(Calendar.MARCH) + 1);
        System.out.println(month);
        String week = getWeek(cal.get(Calendar.DAY_OF_WEEK));
        System.out.println(week);
        System.out.println(cal.get(Calendar.DAY_OF_MONTH));
        System.out.println(cal.getTime());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
        System.out.println(sdf.format(cal.getTime()));
    }
    public static String getWeek(int week){
        String [] strArray = {"", "星期日", "星期一","星期二","星期三","星期四","星期五","星期六"};
        return strArray[week];
    }
    public static String setTwoNu(int nu){
        String s = String.valueOf(nu);
        if( nu <10 ){
            s = "0" + nu;
        }
        return s;
    }
}

import java.util.Calendar;

public class Demo2_Calendar {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.YEAR, 10);
        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH));

        calendar.set(Calendar.MONTH, 10);
        System.out.println(calendar.get(Calendar.MONTH));

        calendar.set(2021,9,01);
        System.out.println(calendar.get(Calendar.YEAR) +""+ (calendar.get(Calendar.MONTH)+1) +"" +calendar.get(Calendar.DAY_OF_MONTH));
    }
}

Calendar 平年润年

import java.util.Calendar;

public class Demo3_Calendar {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        int year = 2020;
        calendar.set(year,2,1);
        calendar.add(Calendar.DAY_OF_MONTH, -1);
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
        if( 29 == calendar.get(Calendar.DAY_OF_MONTH)){
            System.out.println( year + "年是润年");
        } else {
            System.out.println( year + "年是平年");
        }
    }
}

Java的StringBuffer类 Li.034

Thu, 12 Aug 2021 21:57:43 +0800

String 与 StringBuffer 区别

StringBuffer 是线程安全的可变字符序列
String 是一个不可变的字符序列

StringBuffer 的构造函数

public class Demo1_Sb {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        System.out.println(sb.length());
        System.out.println(sb.capacity());

        StringBuffer sb2 = new StringBuffer(10);
        System.out.println(sb2.length());
        System.out.println(sb2.capacity());

        StringBuffer sb3 = new StringBuffer("hello");
        System.out.println(sb3.length());
        System.out.println(sb3.capacity());
    }
}

StringBuffer 的append 和 insert 方法

StringBuffer append() 支持int String StringBuffer boolean, 返回本身,
StringBuffer insert(int , String) 在指定索引添加int String char等, 返回本身, 有可能会越界

public class Demo2_Sb {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append(2);
        System.out.println(sb);
        sb.append("haihai");
        System.out.println(sb);
        sb.append(true);
        System.out.println(sb);
        sb.insert(1,"sss");
        System.out.println(sb);
    }
}

StringBuffer 的deleteCharAt delete方法

StringBuffer deleteCharAt(int index) 删除指定索引的字符, 返回本身, 可能会越界
StringBuffer delete(int start, int end) 删除从start到end, 返回本身, 可能会越界

public class Demo3_Sb {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("Word hen da");
        sb.deleteCharAt(10);
        System.out.println(sb);
        sb.delete(0,4);
        System.out.println(sb);
    }
}

StringBuffer 的 replace reverse方法

StringBuffer replace(int start, int end, String str) 用户str替换从start到end, 返回本身, 可能越界
StringBuffer reverse() 反转字符串, 返回本身

public class Demo4_StringBuffer {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("Hello");
        sb.replace(0,1,"Say");
        System.out.println(sb);

        sb.reverse();
        System.out.println(sb);
    }
}

StringBuffer 的substring方法

String substring(int start) 从索引start开始向后截取, 返回新的String( 不再是StringBuffer本身了 )
String substring(int start, int end) 从start到end(不包含end)截取, 返回新的String( 不再是StringBuffer本身了 )

public class Demo5_StringBuffer {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("Hello");
        String s = sb.substring(3);
        System.out.println(sb);
        System.out.println(s);

        String s2 = sb.substring(0,2);
        System.out.println(s2);
    }
}

StringBuffer 与 String 转换

String -> StringBuffer

构造方法
通过append()方法

StringBuffer -> String

通过构造方法
通过toString()
通过substring(0,length);

public class Demo6_StringBuffer {
    public static void main(String[] args) {
        //String -> StringBuffer
        StringBuffer sb = new StringBuffer("See You Tomorrow");

        StringBuffer sb2 = new StringBuffer();
        sb2.append("HaHa");

        // StringBuffer -> String

        StringBuffer sb3 = new StringBuffer("F Word");

        String s = new String(sb3);

        String s2 = sb3.toString();

        String s3 = sb3.substring(0,sb3.length());

    }
}

使用 StringBuffer 指定格式重新拼接成新的字符串,char[] c = {1,2,3}, 转换成[1, 2, 3]

使用 StringBuffer 中的方法

public class Demo7_StringBuffer {
    public static void main(String[] args) {
        int [] arr = {1,2,3};
        StringBuffer sb = new StringBuffer();
        if( arr.length <= 1){
            sb = sb.append("[").append(sb).append("]");
        }else if ( arr.length > 1 ){
            for (int i=0; i<arr.length; i++) {
                if( 0 == i ){
                    sb = sb.append("[").append(arr[i]);
                } else if ( i > 0 && i != (arr.length-1)){
                    sb = sb.append(", ").append(arr[i]);
                } else if( i == arr.length-1) {
                    sb = sb.append(", ").append(arr[i]).append("]");
                }
            }
        }
        System.out.println(sb);
    }
}

StringBuffer 作为参数传递和 String 作为参数传递

基本数据类型传递, 不改变其值. 引用数据类型传递改变其值
StringBuffer 作为参数传递
String 作为参数传递

public class Demo8_StringBuffer {
    public static void main(String[] args) {
        String s = "Hello";
        System.out.println(s);
        change(s);
        System.out.println(s);

        StringBuffer sb = new StringBuffer(s);
        System.out.println(sb);
        change(sb);
        System.out.println(sb);
    }
    public static void change(String s){
        s = s + "hello";
        return ;
    }
    public static void change(StringBuffer sb){
        sb.append(" Wrold!");
    }
}

冒泡排序

public class Demo9_StringBuffer {
    public static void main(String[] args) {
        int []  arr = {1, 100, 200, 30, 1, 0};
        int temp = 0;
        sortArray(arr);
        printArray(arr);
    }
    public static int[] sortArray(int [] array){
        int temp = 0;
        for (int i=0;i<array.length-1;i++){
            for(int j=array.length-1;j > i;j--){
                if(array[j] < array[j-1]){
                    temp = array[j];
                    array[j] = array[j-1];
                    array[j - 1] = temp;
                }
            }
        }
        return array;
    }
    public static void printArray(int [] array){
        for (int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
    }
}

选择冒泡排序

public class Demo2_SortArray {
    public static void main(String[] args) {
        int [] arr = { 1,22, 30,3, 100};
        selectArray(arr);
        printArray(arr);
    }
    public static int[] selectArray(int []  arr){
        for (int i=0;i<arr.length;i++){
            for (int j=i;j<arr.length;j++){
                if(arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }
    public static void printArray(int [] array){
        for (int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
    }
}

二分查找

public static int search(int [] arr, int t){
    int index = -1;
    int min = 0;
    int max = arr.length;
    int mid = arr.length/2;
    int count = 0;
    while ( count <= Math.log(arr.length)/Math.log(2)){
        if(arr[mid] == t){
            return mid;
        } else if (arr[mid] < t ){
            min = mid + 1;
            mid = (min + max)/2;
        } else if (arr[mid] > t){
            max = mid - 1;
            mid = (min + max)/2;
        }
        count ++;
    }
    return index;
}

Array 类的排序和二分查找

void sort(int[] a) 排序, 快速排序
int binarySearch(int[] a, int key) 在数组中查找key, 找到返回索引位置, 没找到则返回插入-位置-1
String toString(int[] a) 数组转成String 输出

public class Demo4_SortArray {
    public static void main(String[] args) {
        int [] arr = { 15, 100, 1 , 2, 3, 15, 20, 30, 50};

        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));

        int k1 = Arrays.binarySearch(arr, 20);
        System.out.println(k1);
        int k2 = Arrays.binarySearch(arr, 200);
        System.out.println(k2);
    }
}

Integer parseInt 方法

字符串和数字转换
inter 最大值最小值
2 进制 8进制 16进制转换

public class Demo1_Integer {
    public static void main(String[] args) {
        int aInt = Integer.parseInt("190");
        System.out.println(Integer.toBinaryString(aInt));
        System.out.println(Integer.toHexString(aInt));
        System.out.println(Integer.toOctalString(aInt));

        Integer bInt = new Integer("180");
        System.out.println(bInt);
        System.out.println(bInt.toString());

        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }
}

int 和 String 转换

public class Demo2_Integer {
    public static void main(String[] args) {
        // int -> String
        int a =  160;
        String s1 = a + "";

        String s2 = String.valueOf(a);

        Integer i3 = new Integer(a);
        String s3 = i3.toString();

        String s4 = Integer.toString(a);


        // String -> int
        String str = "200";

        int a1 = Integer.parseInt(str);

        Integer ig2 = new Integer(str);
        int a2 = ig2.intValue();
    }
}

Java 基本数据类型自动装箱和拆箱

基本数据类型才可以自动装箱拆箱
Integer Boolean 自动装箱拆箱时需要判断对象不为
byte范围内-128到127内, 不会创建新的对象, 而是从常量池中获取.

public class Demo3_Integer {
    public static void main(String[] args) {
        Integer i = 200;
        System.out.println(i);

        int a = i + 100;
        System.out.println(a);

        Integer a2 = 127;
        Integer a3 = 127;
        Integer a4 = 128;
        Integer a5 = 128;

        System.out.println(a2 == a3);
        System.out.println(a4 == a5);

        System.out.println(a2.equals(a3));
        System.out.println(a4.equals(a5));

        Integer a7 = new Integer(127);
        Integer a8 = new Integer(127);
        System.out.println(a7 == a8);

        // 自动装箱用的Integer.valueOf方法
        Integer a9 = Integer.valueOf(127);
        Integer a10 = Integer.valueOf(127);
        System.out.println(a9 == a10);

        // Integer -> int
        Integer iObject = Integer.valueOf(3);
        int a11 = iObject.intValue();
        System.out.println(a11);
    }
}
// 200 300 T F T T F T 3

Java的String类 Li.033

Tue, 10 Aug 2021 22:15:46 +0800

Scanner

hasNext() 表示判断下一个输入项是否是字符串, hasNextInt() 表示判断下一个输入项是否是int, 否则返回false
next()获取输入项的字符串, nextInt 获取项输入的int

import java.util.Scanner;

public class Demo1_Scanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        if( scanner.hasNextInt()) {
            int p = scanner.nextInt();
            System.out.println(p);
        } else {
            System.out.println("输入内容不是int 数字");
        }
        scanner.close();
    }
}

输入1个整数, 1个数字串, 输出数字和字符串, 错误示例

import java.util.Scanner;

public class Demo2_Scanner {
    public static void main(String[] args) {
        // 输入1个整数, 1个字符串的 错误示例
        Scanner sc = new Scanner(System.in);
        int i = sc.nextInt();
        String s = sc.nextLine();
        System.out.println(i+" "+s);
    }
}

输入1个整数, 1个数字串, 输出数字和字符串, 正确示例, 都当成一行字符串, 后期String转成int类型

import java.util.Scanner;
import java.lang.Integer;;
public class Demo2_Scanner {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s1 = sc.nextLine();
        int i = Integer.parseInt(s1);
        String s2 = sc.nextLine();
        System.out.println(s1+ s2);
    }
}

String 类

toString()方法, 没重写前显示包和类名@hashcode()
常量池的string, 没有则创建, 有则使用现有的string
使用new String()则会创建常量的副本

public class Demo2_String {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = "abc";
        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
}
//结果 false ture

使用+号连接的, 是在StringBuffer中连接后, 再把地址指给变量

public class Demo2_String {
    public static void main(String[] args) {
        String s4 = "ab";
        String s5 = s4 + "c";
        System.out.println(s4 == s5);
    }
}
// false

String 其他方法

startWith endWith equalsIgnoreCase contains

public class Demo3_String {
    public static void main(String[] args) {
        String sm = "123 sdf z";
        String s1 = "123";
        String s2 = "z";
        String s3 = "123 SDF z";
        String s4 = "sdf";
        String s5 = "sDf";
        System.out.println(sm.startsWith(s1));
        System.out.println(sm.endsWith(s2));
        System.out.println(sm.equalsIgnoreCase(s3));
        System.out.println(sm.contains(s4));
        System.out.println(sm.contains(s5));
        System.out.println(sm.toLowerCase().contains(s4.toLowerCase()));
    }
}
//  T T T T F T

String练习, 模拟用户登录

import java.util.Scanner;

public class Demo4_String {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String name = "";
        String passwd = "";
        for(int i=0;i<3;i++){
            System.out.println("请输入用户名:");
            if( sc.hasNextLine() ){
                name = sc.nextLine();
            }
            System.out.println("请输入用户密码:");
            if( sc.hasNextLine() ){
                passwd = sc.nextLine();
            }
            if( "admin".equals(name) && "admin".equals(passwd) ){
                System.out.println("欢迎"+ name + "登录!");
                break;
            } else {
                if( (2-i)==0 ){
                    System.out.println("请找回密码, 或过1小时后再重试 !");
                } else{
                    System.out.println("用户名或密码错误, 您还有" + (2-i) + "次机会!");
                }
            }
            name = "";
            passwd = "";
        }
        sc.close();
    }
}

String 的方法

char charAt(int index) 获取指定索引位置的字符
int length() 获取字符串长度
int indexOf(int ch) 获取字母在字符串第一次出现的索引
int indexOf(String str) 获取字符串第一次出现的出现的索引位置
int indexOf( int ch, int fromIndex ) 从指定索引位置向后, 字母ch 第一次出现的索引位置
int indexOf( String str, int fromInex ) 从指定索引位置向后, str 第一次出现的索引位置
int lastIndexOf(int ch) 最后一次出现字符的索引, 即从后向前找第1次出现字母的索引
int lastIndexOf(int ch, int fromIndex) 从指定索引向前找, 字素ch 出现的索引
int lastIndexOf(String str)
int lastIndexOf(String str, int fromIndex)
String substring(int beginIndex) 从索引位置开始到结尾截取字符串
String substring(int beginIndex, int endIndex) 从开始索引到结束索引位置前(结束索引不包含) 截取字符串

public class Demo5_String {
    public static void main(String[] args) {
        String sm = "Hello Wrold!";
        System.out.println(sm.charAt(0));
        //System.out.println(sm.charAt(20));

        System.out.println(sm.length());

        System.out.println(sm.indexOf('l'));
        System.out.println(sm.indexOf('z'));

        System.out.println(sm.indexOf("Wrold"));
        System.out.println(sm.indexOf("Wrood"));

        System.out.println(sm.indexOf('o',5));

        System.out.println( sm.indexOf( "old", 5 ) );
    }
}

public class Demo6_String {
    public static void main(String[] args) {
        String s = "ET drive UFO! So COOL";

        System.out.println(s.lastIndexOf('O'));

        System.out.println(s.lastIndexOf('O',17));

        System.out.println(s.lastIndexOf("UFO"));

        System.out.println(s.lastIndexOf("So", 9));
    }
}

public class Demo7_String {
    public static void main(String[] args) {
        String s = "PhpIsBest?";
        System.out.println(s.substring(3));

        System.out.println(s.substring(0,3));
    }
}

String 练习, 统计大写, 小写, 数字, 其他字符个数

public class Demo9_String {
    public static void main(String[] args) {
        String s = "C C++ C# Go Java Javascript Php Swift 2021";
        int sumUp    = 0;
        int sumLow   = 0;
        int sumNu    = 0;
        int sumOther = 0;
        for(int i=0;i<s.length();i++){
            char tmpChar = s.charAt(i);
            if( tmpChar <= 'z' && tmpChar >= 'a'){
                sumLow++;
            } else if( tmpChar <= 'Z' && tmpChar >= 'A' ){
                sumUp++;
            } else if( tmpChar <= '9' && tmpChar >= '0' ){
                sumNu++;
            } else if( ' ' == tmpChar ){

            } else {
                sumOther++;
            }
        }
        System.out.println(sumUp+"," + sumLow + "," + sumNu + "," + sumOther);
    }
}

String 的方法

byte[] getBytes() 字符串转换为字节数组
char[] toCharArray() 字符串转换为字符数线
String valueOf(char[] data) 字符数组转化为字符串
String valueOf(int i) 把 int 转换为字符串, (valueOf 可以任意类型的数据转化为字符串)
String toLowerCase() 字符串转换成小写
String toUpperCase() 字符串转换大写
concat(String str) 字符串拼接

public class Demo10_String {
    public static void main(String[] args) {
        String s = "Hello";
        byte [] b = s.getBytes();
        for(int i=0;i<b.length;i++){
            System.out.print(b[i]+" ");
        }
        System.out.println();

        char[] c = s.toCharArray();
        for(int i=0;i<c.length;i++){
            System.out.print(c[i] + " ");
        }
        System.out.println();

        String s2 = String.valueOf(c);
        System.out.println(s2);

        String s3 = String.valueOf(10);
        System.out.println(s3);

        System.out.println(s.toLowerCase());

        System.out.println(s.toUpperCase());

        System.out.println(s.concat(" Wrold!"));
    }
}

String 练习, 首字母大写, 其他小写

public class Demo11_String {
    // 字符串首写字母大写, 其他字母小写
    public static void main(String[] args) {
        String s = "what Is A Youth?";
        if(s.length() > 0){
            System.out.println(s.substring(0,1).toUpperCase() + s.substring(1).toLowerCase());
        }
    }
}

String 练习, int [] arr = {1,2,3}; 转换成指定格式 {1, 2, 3}的字符串.

public class Demo12_String {
    // int [] arr = {1,2,3}; 转换成指定格式 {1, 2, 3}的字符串.
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5};
        String s = "";
        if( 1 == arr.length ){
            s = "{"+ arr[0]+"}";
        }
        if( arr.length > 1 ){
            for (int i=0; i<arr.length; i++) {
                if ( 0 == i ){
                    s = "{" + arr[i] + ", ";
                }
                else if( i < arr.length - 1 ){
                    s = s + arr[i] + ", ";
                }
                else if( i == arr.length-1 ){
                    s = s + arr[i] + "}";
                }
            }
        }
        System.out.println(s);
    }
}

String 中的方法

String replace(char oldChar, char newChar) 用新字符替换所有旧的字符
String replace(CharSequence target, CharSequence replacement) 使用新字符串替换旧的字符串
int compareTo(String anotherString) 比较2个字符串
int compareToIgnoreCase(String str) 忽略大小写比较2个字符串

public class Demo13_String {
    public static void main(String[] args) {
        String s = "Switch Mario";

        String s2 = s.replace('i','a');
        System.out.println(s2);

        String s3 = s.replace("Mario", "Zelda");
        System.out.println(s3);

        String s4 = "     switch one  ";
        System.out.println("{"+s4.trim()+"}");

        String s5 = "sEE";
        String s6 = "see";
        int sum = s5.compareTo(s6);
        System.out.println(sum);

        int sum2 = s5.compareToIgnoreCase(s6);
        System.out.println(sum2);
    }
}

String 练习反转字符串

import java.util.Scanner;
public class Demo14_String {
    //反转字符串
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = "";
        String s2 = "";
        if( sc.hasNextLine() ){
            s = sc.nextLine();
        }
        char [] cs = s.toCharArray();
        for (int i=0; i<(cs.length/2); i++) {
            char temp = cs[cs.length-1-i];
            cs[cs.length-1-i] = cs[i];
            cs[i] = temp;
        }
        System.out.println(new String(cs));

        char [] cs2 = s.toCharArray();
        for (int i=cs2.length-1; i>=0; i--) {
            s2 = s2 + cs2[i];
        }
        System.out.println(s2);
    }
}

String 练习, 查找str在另一个str出现的次数

public class Demo15_String {
    public static void main(String[] args) {
        String sMax = "Whatever is worth doing is worth doing well.";
        String sMin = "worth";
        int sum   = 0;
        int j     = 0;
        int index = 0;
        while(index<sMax.length()){
            j = sMax.indexOf(sMin, index);
            if(-1 == j){
                break;
            } else{
                index = j + 1;
                sum++;
            }
        }
        System.out.println(sum);
    }
}

Java重写equals方法 Li.032

Tue, 10 Aug 2021 21:49:52 +0800

未重写前equals是比较引用的地址, 如比较2个对象, 地址一定是不同的

重写后, 可以比较对象的属性相同, 则认为对象相同

public class Demo1_Object {
    private int age;
    private String name;
    Demo1_Object(){}
    Demo1_Object(int age,String name){
        this.age  = age;
        this.name = name;
    }
    public static void main(String[] args) {
        Demo1_Object d  = new Demo1_Object(12, "xiaoming");
        Demo1_Object d2 = new Demo1_Object(12, "xiaohong");
        Demo1_Object d3 = new Demo1_Object(12, "xiaoming");
        System.out.println(d.equals(d2));
        System.out.println(d.equals(d3));
    }
    public boolean equals(Object obj){
        // 重写Object 类中equals方法
        if( obj instanceof Demo1_Object ){
            Demo1_Object demo = (Demo1_Object)obj;
            return this.name.equals(demo.name) && this.age == demo.age;
        }
        return false;
    }
    public boolean equals(Demo1_Object dobj){
        //这个不是重写, 是重载
        return this.name.equals(dobj.name) && this.age == dobj.age;
    }
    public String toString(){
        return (age + name);
    }
}

Java面向对象 Li.031

Fri, 06 Aug 2021 17:14:22 +0800

Package

包只能类的首行 com.lizica.java
默认编译是不会创建包的文件夹, 加入参数 -d .才会创建
运行类的方式就变了, 必须带上包的路径才的运行类

javac -d . Demo1_Package.java
java com.lizicai.java.Demo1_Package

package com.lizicai.java;
public class Demo1_Package {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

引用时候3种方式, 推荐导入具体的类,第2种

class Demo2_Package{
    public static void main(String[] args) {
        com.lizicai.java.Demo1_Package d = new com.lizicai.java.Demo1_Package();
        d.sprint();
    }
}

import com.lizicai.java.Demo1_Package;
class Demo2_Package{
    public static void main(String[] args) {
        Demo1_Package d = new Demo1_Package();
        d.sprint();
    }
}

import com.lizicai.java.*;
class Demo2_Package{
    public static void main(String[] args) {
        Demo1_Package d = new Demo1_Package();
        d.sprint();
    }
}

不同类修饰符和包访问关系

类修饰符	本类	同一个包下(子类和无关系)	不同包下(子类)	不同包下(无关系)
private
默认
protected
public

Java 修饰符总结

修饰符

权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract

类的修饰符

权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract
用的最多的就是：public

成员变量的修饰符

权限修饰符：private，默认的，protected，public
状态修饰符：static，final
用的最多的就是：private

构造方法的修饰符

权限修饰符：private，默认的，protected，public
用的最多的就是：public

成员方法

权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
用的最多的就是：public

组合规则

成员变量：public static final
成员方法：public static, public abstract, public final

内部类

public class Demo3_Iner {
    public static void main(String[] args) {
        Outer.Inner aa = new Outer().new Inner();
        aa.method();
    }
}
class Outer{
    class Inner{
        public void method(){
            System.out.println("InerClass");
        }
    }
}

静态内部类

public class Demo4_StaticInner {
    public static void main(String[] args) {
        Outer.Inner aa = new Outer.Inner();
        aa.method();
    }
}
class Outer{
    static class Inner{
        public void method(){
            System.out.println("InerClass");
        }
    }
}

内部类调用外部类成员

public class Demo5_Inner {
    public static void main(String[] args) {
        Outer.Inner o = new Outer().new Inner();
        o.method();
    }
}
class Outer{
    private int num = 30;
    class Inner{
        private int num = 20;
        public void method(){
            int num = 10;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Outer.this.num);
        }
        public int getNum() {
            return num;
        }
    }
    //外部类调用内部类成员
    public void test(){
        Inner n = new Inner();
        System.out.println(n.getNum());
    }
}

public class Demo7_Inner {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.printe();
    }
}
interface Inter1{
    public void method();
}
class Outer{
    class Inner implements Inter1{
        public void method(){
            System.out.println("LLL");
        }
    }
    public void printe(){
        Inner i = new Inner();
        i.method();
    }
}

匿名内部类, 只能放在方法内, 推荐只有一个方法的类才使用匿名内部类.

public class Demo8_Inner {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.test();
    }
}
interface Inter2{
    public void method();
    public void method2();
}
class Outer{
    public void test(){
        new Inter2(){
            public void method(){
                System.out.println("HHH");
            }
            public void method2(){
                System.out.println("KKK");
            }
        }.method();
        new Inter2(){
            public void method(){
                System.out.println("HHH");
            }
            public void method2(){
                System.out.println("KKK");
            }
        }.method2();
    }
}

public class Demo9_Inner {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.test();
    }
}
interface Inter2{
    public void method();
    public void method2();
}
class Outer{
    public void test(){
        Inter2 i = new Inter2(){
            public void method(){
                System.out.println("HHH");
            }
            public void method2(){
                System.out.println("KKK");
            }
        };
        i.method();
        i.method2();
    }
}

匿名内部类当作参数使用

public class Demo10_Inner {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method(new Inter(){
            public void method(){
                System.out.println("NoName");
            }
        });
    }
}
interface Inter{
    public void method();
}
class Outer {
    public void method(Inter i){
        i.method();
    }
}

匿名内部类当前返回类型使用

public class Demo11_Inner {
    public static void main(String[] args) {
        Outer.method().show();
    }
}
interface Inter{
    public void show();
}
class Outer {
    public static Inter method(){
        return new Inter(){
            public void show(){
                System.out.println("HaHaHa...");
            }
        };
    }
}

面向对象(成员变量和局部变量的区别)

在类中的位置不同

成员变量: 在类中方法外
局部变量: 在方法宣言中或者方法声明上

在内存中位置不同

成员变量: 在堆内存(成员变量属于对象, 对象进堆内存)
局部变量: 在栈内存(局部变量属于方法, 方法进栈内存)

生命周期不同

成员变量: 随着对象的创建而存在, 随着对象的消失而消失
局部变量: 随着方法的调用而存在, 随着方法的调用完毕而消失

初始化值不同

成员变量: 有默认初始化值
局部变量: 没有默认初始化值, 必须定义, 赋值, 然后才能使用.

注意事项

局部变量名称可以和成员变量名称一样, 在方法中使用的时候, 采用的是就近原则
基本数据类型变量包括哪些: byte,short,int,long,float,double,boolean,char
线上服务数据类型变量包括哪些: 数组, 类, 接口, 枚举

静态代码块构造代码块构造方法搜索顺序

public class FuZi {
    public static void main(String[] args) {
        Fu f = new Zi();
    }
}
class Fu{
    static {
        System.out.println("Fu static");
    }

    {
        System.out.println("Fu 构造代码块");
    }

    Fu(){
        System.out.println("Fu 构造方法");
    }
}

class Zi extends Fu{
    static {
        System.out.println("Zi static");
    }

    {
        System.out.println("Zi 构造代码块");
    }

    Zi(){
        System.out.println("Zi 构造方法");
    }
}

Fu static
Zi static
Fu 构造代码块
Fu 构造方法
Zi 构造代码块
Zi 构造方法

面向对象( 方法重写概述及其应用 )

方法重写是什么

子父类出现一模一样的方法( 注意: 值返回值类型可以是子父类)

方法重写的应用

当子类需要父类的功能, 而功能主体子类有自己的特有内容时, 可以重写父类中的方法

方法重写注意事项

父类中私有方法不能被重写, 因为父类私有方法子类根本无法继承
子类重写父类方法时, 访问权限不能更低, 最好一致
父类静态方法, 子类也必须通过静态方法进行重写,( 其实是静态的覆盖 )

抽象类

抽象类必须是abstract 修饰
抽象方法必须有abstract 修饰
抽象类不一定有抽象方法(可以全是非抽象方法), 有抽象方法的一定是抽象类或者接口
抽象类不能实例化, 可以由继承的子类实例化
抽象类的子类要么是抽象类要么实现全部接口的非抽象类

抽象类成员特点

抽象类成员特点: 既可以是变量也可以是常量, abstract 不能修饰成员变量
构造方法: 有, 用于子类访问父类数据的初始化.
成员方法, 既可以是抽象的, 也可以是非抽象的.

Java接口和类 Li.030

Thu, 05 Aug 2021 23:22:27 +0800

Java 类和接口

类和类只能是继承, 类不能继承构造函数
类与接口, 类可以实现多个接口, 不能继承接口
接口与接口, 接口可以继承多个接口, 不能实现接口
类类接口, 类只能继承一个类, 同时实现多个接口

抽象类与接口

抽象类

成员变量: 常量或者变量
构造方法: 有
成员方法: 可以抽象, 也可以非抽象

接口

成员变量: 常量
成员方法: 抽象方法, 强制, 不写也会默认抽象

abstract class Demo1_Animal {
    public static void main (String[] args) {
        Cat c = new Cat(12, "美短");
        c.eat();
        c.sleep();
        JumpCat jumpCat = new JumpCat(1, "跳高猫");
        jumpCat.eat();
        jumpCat.sleep();
        jumpCat.jump();
    }
}

abstract class Animal{
    private int age;
    private String name;

    Animal(){ }
    Animal(int age, String name){
        this.age = age;
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName() {
        return name;
    }
    abstract public void eat();
    abstract public void sleep();
}

class Cat extends Animal{
    private int age;
    private String name;
    Cat(){}
    Cat(int age, String name){
        super(age, name);
    }
    public void eat(){
        System.out.println("Fish");
    }
    public void sleep(){
        System.out.println("sleep whit bowl");
    }
}
interface Jump{
    public void jump();
}

class JumpCat extends Cat implements Jump{
    JumpCat(){}
    JumpCat(int age, String name){
        super(age,name);
    }
    public void jump(){
        System.out.println("jump height");
    }
}

2021计划 Li.029

Thu, 05 Aug 2021 17:26:29 +0800

计划

时间过的太快了

俺30了

说真的还没有什么能拿出手的技能

感觉一线越来越难生存

分分钟失业

中年焦虑

生活有点难

之前估算的, 要想留在一线, 工资至少30K才行

也没

所以考虑回省会变成一迫切的问题了

看了省会情况, 没啥重要技能难找工作的

下一段时间, 计划学习Java

至少能写个项目出来

这样回省会不至于饿死

就这样

2021 年 08 月 05 日周四

Hugo学习路线 Li.028

Wed, 04 Aug 2021 23:09:07 +0800

1. Hugo 学习路线

Hugo学习路线

1.1 基础

了解Hugo, 使用Hugo命令和Github, 搭建起来静态博客

Hugo和GitHub Pages搭建静态网站Li.004

了解一下常用hugo命令

Hugo常用命令Li.023

Hugo使用Markdown标记语言, Markdown语法学习是必要的, 仅有十几个标签

Markdown语法Li.002

找一个顺手的Markdown编辑器, 用来写作

Markdown编辑软件Li.003

1.2 进阶

解决Markdown图片存放问题

Hugo中Markdown图片资源存放几种方式Li.024

推荐存放在Github(2.1方式)上, 免费, 容易操作

1.3 难度

Hugo静态网站常用管理方式, 使用自有域名

Hugo静态网站常用管理方式Li.026

推荐方式1.2使用Github, 配置自己的域名, 免费

Hugo的Shortcode模板片段,插入视频, 定制网页

Hugo的shortcode(支持视频等)和主题修改Li.027

插入bilibili和YouTube视频, Hugo完全可以作为自媒体平台了

Hugo的shortcode(支持视频等)和主题修改 Li.027

Tue, 03 Aug 2021 22:32:56 +0800

本篇文章属于Hugo学习路线Li.028一部分

1. Hugo的Shortcodes是什么?

shortcode 是一些可以直接插入内容文档中的助记符，在Hugo 生成网站时，会将这些助记符替换为相应的HTML 代码片段（严格来说是模板片段)

2. 为什么需要Shortcodes.

虽然Markdown 支持html标签, 写起来相当麻烦, 碰到页面兼容性问题, 就得修改所有写了Html的Markdown文件, 想想都可怕

shortcode像如下, 类似特殊Markdown标记语言

显示效果

步骤, shortcode示例

可在Markdown中使用, 如果出现问题, 只需要修改模板片段即可.

3. Shortcodes 可以用来做什么, 嵌入视频之类, Hugo静态博客也能是自媒体.

3.1 可在网页嵌入视频, 常用网站Bilibili 和 Youtube.

在hugo网站目录layouts/shortcodes中创建bilibili.html文件

文件名称bilibili, 引用的时候也是相同名称

<style>
.meta-media {
  position: relative;
  margin-bottom: 30px;
  display: flex;
  width: 100%;
  height: 0;
  padding-bottom: 75%;
}
.video {
  position: absolute;
  width: 100%;
  height: 100%;
  left: 0;
  top: 0;
}
</style>
<div class="meta-media">
    <iframe src="{{ .Get "src" }}&high_quality=1" frameborder="no" scrolling="yes" allowfullscreen="allowfullscreen" high_quality="1" framespacing="1" class="video" >
</iframe>
</div>

复制bilibili视频代码

示例视频地址

复制嵌入代码

得到如下, 复制src双引号内容

<iframe src="//player.bilibili.com/player.html?aid=973574581&bvid=BV1144y167iZ&cid=352795710&page=1" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"> </iframe>

引用

复制src到shortcode格式内

Youtube, 在layouts/shortcodes创建youtube.html

同名会覆盖Hugo原生的youtube shortcode

<style>
.meta-media {
  position: relative;
  margin-bottom: 30px;
  display: flex;
  width: 100%;
  height: 0;
  padding-bottom: 75%;
}
.video {
  position: absolute;
  width: 100%;
  height: 100%;
  left: 0;
  top: 0;
}
</style>
<div class="meta-media">
<iframe src="https://www.youtube.com/embed/{{ .Get "embed" }}" frameborder="no" scrolling="yes" allowfullscreen="allowfullscreen" high_quality="1" framespacing="1" class="video" >
</iframe>
</div>

引用

静态博客嵌入视频完成, 完全可以作为自媒体平台

4. 创建一个shortcode

<div style="justify-content: center;text-align:center;color: var(--secondary);">
<div >
    <img src="{{ .Get "src" }}" alt="{{ .Get "title" }}" style="max-width: {{ .Get "max-width" }}px; max-height: {{ .Get "max-height" }}px;">
    <p style="padding-top:6px;font-size:15px;letter-spacing: 0.03rem;" >{{ .Get "title" }}</p>
</div>
</div>

其中{{ .Get “title” }}是shortcode引用时使用的参数名称中引号内容title=""

src是图片链接

其中{{ .Get “len” }}定义图片最大长度, 可以省略, 无限制

标题在图片下面

5. 以 hugo-PaperMod 主题为例

5.1 papermod/assets/css/core/theme-vars.css中控制黑暗/白天主题显示, 更改就可看到效果

5.2 更改黑暗主题颜色, 就能和 Lizicai.com 黑暗主题一致.

单纯黑色对比太强烈了, 更改成灰蓝色了

.dark {
    /*--theme: #1d1e20;*/
    --theme: #3c4456;
    /*--entry: #2e2e33;*/
    --entry: #323442;
    --primary: rgba(255, 255, 255, 0.84);
    --secondary: rgba(255, 255, 255, 0.56);
    --tertiary: rgba(255, 255, 255, 0.16);
    --content: rgba(255, 255, 255, 0.74);
    --hljs-bg: #2e2e33;
    /*--code-bg: #37383e;*/
    --code-bg: #313742;
    --border: #333;
}

Hugo静态网站常用管理方式 Li.026

Mon, 02 Aug 2021 23:59:19 +0800

1. 列表出全部方式

1.1 本地文章Hugo生成静态网站->上传Github, Github提供域名

1.2 本地文章Hugo生成静态网站->上传Github, 使用自有域名, 配置域名CNAME

1.3 本地文章Hugo生成静态网站->(rsycn)上传自己服务器上, 使用自有域名

1.4 本地文章Hugo生成静态网站->上传Github->(使用Github action)在服务器上拉取Github静态网站, 使用自有域名

1.5 本地文章Hugo生成静态网站->上传Github->(使用crontab 定时任务)在服务器上拉取Github静态网站, 使用自有域名

1.6 本地文章->上传服务器->服务器Hugo生成静态网站, 使用自有域名

1.7 服务器文章->服务器Hugo生成静态网站, 使用自有域名

2. 方式比较

方式	是否推荐	是否免费	更新及时	是否使用自有域名	难易程度(1最容易)
1.1方式
1.2方式
1.3方式
1.4方式
1.5方式
1.6方式
1.7方式

1.1方式(推荐), 免费, 更新及时, 会使用Hugo Git Markdown即可, 最简单的方式.

1.2方式(推荐), 除了1.1有的内容, 可使用自己域名.

1.3方式(推荐), 方式简单, 更新及时,会使用Hugo Markdown rsycn 配置ssh key即可

1.4方式(推荐), 自动化程序最高, 只需要上传到Github就可触发, 更新及时, 难度也稍微高点. 除会使用Hugo Git Markdown, 还需要使用Github action, SSH KEY配置.

1.5方式, 如半小时拉一次Github, 则有延时

1.6 1.7 更新同样及时, 不够自动化, 需要手动登录服务器执行.

3. 推荐方式使用, 1.1, 1.2, 1.3, 1.4 方式.

3.1 (方式 1.1 使用)

1.1方式使用参考

3.2 (方式 1.2 使用)

完成1.1方式

购买域名, 设置设置CNAME记录

设置CNAME记录mywebsite.lizicai.com leezicai.github.io

在Github Pages设置域名, 会在Github项目中生成一个文件

~/mywebsite/mywebsite拉取Github静态网站, 获取步骤2的文件

这一步必须执行

git pull

重新设置baseUrl, 因为域名更改了

直接访问http://mywebsite.lizicai.com, 显示错误

页面显示错误

cd ~/mywebsite
hugo --theme=papermod --baseUrl="https://mywebsite.lizicai.com/" --destination=mywebsite

cd mywebsite
# 远程仓库名称github, 在方式1.1重命名过, 注意, 未重命名则是orign
git add  .
git commit -m  "test"
git push orign master

检查

正确显示内容

3.3 (方式 1.3 使用), rsycn用法

设置SSH Key

ssh-keygen -t ed25519
ssh-copy-id -i ~/.ssh/test.pub root@192.168.1.100  -p 22

# vim ~/.ssh/config,存入以下内容
Host myhost
 User root
 Port 22
 HostName 192.168.1.100
 PreferredAuthentications publickey
 IdentityFile ~/.ssh/test

以lizicai.com网站为例

upli(){
    LOCAL_PATH="${HOME}/lizicai/lizicai.com/"
    SERVER_PATH="lizicai.com/"
    echo "\033[42;30m Begin rsync ${LOCAL_PATH} myhost:${SERVER_PATH}...  \033[0m"
    rsync -aut --delete --exclude '.DS_Store' ${LOCAL_PATH} myhost:${SERVER_PATH}
    echo "\033[42;30m Finash.  \033[0m"
}

3.4 (方式 1.4 使用), Github Action 事件驱动的，意味着您可以在指定事件发生后运行一系列命令. 比如push后就登录服务器拉取Github代码.

设置SSH Key

ssh-keygen -t ed25519
# test.pub复制到服务器root@192.168.1.100上.
ssh-copy-id -i ~/.ssh/test.pub root@192.168.1.100  -p 22

# vim ~/.ssh/config,存入以下内容
Host myhost
 User root
 Port 22
 HostName 192.168.1.100
 PreferredAuthentications publickey
 IdentityFile ~/.ssh/test

生成密钥

ls查看生成的密钥

配置Github SSH keys

https://github.com/settings/keys

将test.pub内容复制上去即可

服务器上设置Github SSH keys

# 使用scp将~/.ssh/test复制到服务器上
scp ~/.ssh/test myhost:.ssh/

# 登录服务, 配置
ssh myhost
# vim ~/.ssh/config添加如下内容
Host github.com
 User git
 HostName github.com
 PreferredAuthentications publickey
 IdentityFile ~/.ssh/test

服务器上拉取Github静态网站内容

ssh myhost

cd ~

git clone git@github.com:leezicai/lizicai.com.git

Nginx配置, 供参考

server{
    listen 80;
    server_name lizicai.com;
    return 301 https://lizicai.com$request_uri;
}
server {
    listen       443 ssl;
    server_name  lizicai.com;
    charset utf-8;
    ssl_certificate /root/cert/lizicai.com/fullchain.pem;
    ssl_certificate_key /root/cert/lizicai.com/private.key;

    #charset koi8-r;
    #access_log  /var/log/nginx/host.access.log  main;

    location / {
        root   /root/lizicai.com/;
        index  index.html index.htm;
    }
    error_page  404              /404.html;

    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /root/lizicai.com/;
    }
}

配置Github Action的Secrets

设置Github Action

使用步骤1 SSH Key内容, 配置如下参数

HOST 192.168.1.100
PORT 22
USERNAME root
KEY 复制~/.ssh/test中的内容

在https://github.com/leezicai/lizicai.com项目添加Github Action

# 这里是github静态网站目录
cd ~/lizicai/lizicai.com
# 创建文件夹
mkdir -p .github/workflows
# vim git-pull-lizicai-com.yml, 添加如下内容

name: Git Pull Lizicai.com

on:
  push:
    branches:
      - master

jobs:
  ssh-job:
    name: git pull lizicai.com  job
    runs-on: ubuntu-latest
    steps:
      - name: ssh git pull
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.HOST }}
          username: ${{ secrets.USERNAME }}
          key: ${{ secrets.KEY }}
          port: ${{ secrets.PORT }}
          script: |
            cd ${HOME}/lizicai.com
            git pull

上传Github Action文件到github就会自动执行了

cd ~/lizicai/lizicai.com
git add .
git commit -m "Github action"
# 远程仓库origin已改名为github
git push github master

查看Github Action执行情况

每次推送时就会触发, 在服务器上登录, 拉取Github代码

执行成功

rsycn同步图片或其他资源到服务器上 Li.025

Mon, 02 Aug 2021 17:39:14 +0800

1. rsycn 是什么

rsycn最大特点是可以检查本地和远程的文件差异, 只上传变动的文件. sftp 是全量上传.

rsycn 会用在上传图片到Nginx服务器上, 作为图床使用

2. rsycn安装

Mac

brew install rsycn

Linux

yum install rsycn

Windows

choco install rsycn

3. rsycn 命令

-r 参数, 递归同步, 同步文件夹时使用

rsycn -r source destination

-a 参数, 除了可以递归同步以外，还可以同步元信息（比如修改时间、权限等）.

rsycn -a source destination

-u 跳过目标目录比源目录修改时间新的文件, 不同步这些文件

rsycn -ru source destination

-t 保留文件的修改时间

rsycn -aut source destination

–exclude 排除某些文件

rsycn -aur --exclude '.DS_Store' source destination

–include 与–exclude连用

rsycn -aur --exclude '*' --include "readme.md" source destination

–delete 删除目标目录中与源目录不一致文件

rsync -aut --delete --exclude '.DS_Store' source destination

4. 与ssh key连用, 上传到服务器上

4.1 配置ssh key

使用ssh命令生成密钥

ssh-keygen -t ed25519

生成密钥

ls查看生成的密钥

ssh命令把公钥复制copy到服务器上

# 输入对应root用户密码即可完成
ssh-copy-id -i ~/.ssh/test.pub root@192.168.1.100  -p 22

配置~/.ssh/config

添加如下配置, 用户名端口 ip与上面一致, 私钥则是test

Host myhost
 User root
 Port 22
 HostName 192.168.1.100
 PreferredAuthentications publickey
 IdentityFile ~/.ssh/test

设置上传的脚本

如下内容放到~/.zshrc或~/.bashrc中

把本地~/Pictures/s.lizicai.com/下子文件文件夹上传到myhost的root用户根目录s.lizicai.com/目录中

myhost名称是步骤3中的Host名称

upli(){
    LOCAL_PATH="${HOME}/Pictures/s.lizicai.com/"
    SERVER_PATH="s.lizicai.com/"
    echo "\033[42;30m Begin rsync ${LOCAL_PATH} myhost:${SERVER_PATH}...  \033[0m"
    rsync -aut --delete --exclude '.DS_Store' ${LOCAL_PATH} myhost:${SERVER_PATH}
    echo "\033[42;30m Finash.  \033[0m"
}

重新生效

source ~/.zshrc
# 或source ~/.bashrc, 取决使用哪种shell

命令行上传

upli

上传图片或资源

Hugo中Markdown图片资源存放几种方式 Li.024

Sun, 01 Aug 2021 23:14:57 +0800

本篇文章属于Hugo学习路线Li.028一部分

1. Hugo中Markdown图片资源放在哪? 一直是个问题

引用其他资源担心其他网站改动路径, 就没了, 建立自己的网络图片资源库就显得很重要了.

存放Hugo的静态网站中, 引用起来不方便, 而且更新图片时必须更新网站, 强依赖.

所以一个独立的图片库就显示有必要了.

图片压缩也少不了.

2. 常用几种存放图片资源方式. Github 使用Nginx做为静态资源自建私有云自建图床使用云存储服务.

2.1 Github或Gitee(国内理论理论速度更快) 公共项目存放图片资源. 这种方式只需要更新图片即可, 不需要更新静态博客, 管理更方便. 免费.

免费, 会使用git就可以. 也可使用图形界面PicGo上传图片到Github

示例, 复制文件下载链接即可在markdown使用

复制文件下载链接即可在markdown使用

![number1](https://github.com/leezicai/share/raw/master/icon/number/1.png)

2.2 静态博客存放在Github, 图片也存放在同一项目下. 免费.

免费, 会使用Git

如果存放在Hugo文件夹中static中, 虽然文件生成在项目根目录下, 但在Github上地址从baseUrl开始的

# 图片存放在static文件夹下

https://github.com/adityatelange/hugo-PaperMod/tree/exampleSite/static 



# 图片地址起始https://adityatelange.github.io/hugo-PaperMod/
![papermod-cover.png](https://adityatelange.github.io/hugo-PaperMod/papermod-cover.png)

单个图片,如果有文件夹则添加

2.3 使用Nginx或其他服务器做静态资源. Nginx安装参考地址 , 付费, 需要服务器.

Nginx default.conf配置

使用sftp上传图片到服务器的s.lizicai.com文件夹下即可

server {
    listen       80;
    server_name  s.lizicai.com;
    return 301 https://s.lizicai.com$request_uri;
}
server {
    listen       443 ssl;
    server_name  s.lizicai.com;
    charset utf-8;
    ssl_certificate /root/cert/s.lizicai.com/fullchain.pem;
    ssl_certificate_key /root/cert/s.lizicai.com/private.key;
    location / {
        root   /root/s.lizicai.com/;
        index  index.html index.htm;
        autoindex on;
        autoindex_localtime on;
        autoindex_exact_size off;
    }
    error_page  404              /404.html;

    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /root/s.lizicai.com/;
        autoindex_localtime on;
        autoindex_exact_size off;
    }
}

示例地址 https://s.lizicai.com/icon/tags/ , 右键复制blue.png的链接

![tagblue](https://s.lizicai.com/icon/tags/blue.png)

3. 上传前的图片压缩软件.

ImageOptim 支持Mac

图压支持Mac Windows

squoosh.app Chrome 浏览器应用支持Mac Windows Linux

pinga 支持Windows

Hugo常用命令 Li.023

Sat, 31 Jul 2021 17:00:14 +0800

本篇文章属于Hugo学习路线Li.028一部分

Hugo 常用命令. 官网参考地址

# 查询所有命令
hugo -h

# 创建Hugo 静态网站
hugo new site mywebsite

# 创建文章, 当前必须mywebsite下才可创建文章
# 创建的文章存放在 mywebsite/content/p/test.md下
# 使用命令创建的hogo可以监控到, 实时显示到预览上
hugo new p/test.md

# 启动服务, 必须在mywebsite文件夹下启动
hugo server

# 草稿也预览, -D 参数, 必须在mywebsite文件夹下启动
hugo -D server

# 指定预览的主题, 必须在mywebsite文件夹下启动
# papermod是在themes文件夹下的主题名称
hugo -D server --theme=papermod

# 指定预览的端口
hugo -D server  --port=1313

# 指定服务绑定在哪个端口, 比如你想在手机预览, 电脑手机同一局域网时
# 电脑ip 192.168.1.20, 手机访问192.168.1.20就能看到预览
hugo -D server --bind="192.168.1.20" --port=80

# 指定预览的默认地址, http://192.168.1.20:1313

错误示例

hugo -D server --baseUrl="http://192.168.1.20/" --port=1313
# 访问不到, 没有绑定ip, 访问http://192.168.1.20:1313失败, 访问localhost:1313则显示
# 访问任意链接被定位到http://192.168.1.20:1313上


正确做法,绑定当前ip,提醒baseUrl最后结尾必须是'/'

hugo -D server --baseUrl="http://192.168.1.20/" --port=1313 --bind="192.168.1.20"

# 指定配置文件
hugo -D server --config=config.yml

# 指定输出静态博客网站的目录lizicai.com, 再次提醒baseUrl最后一位是/
hugo --theme=papermod --baseUrl="https://lizicai.com/" --destination="lizicai.com" --config=config.yml

RSS和一些RSS订阅网站 Li.022

Thu, 29 Jul 2021 23:57:14 +0800

1. RSS是什么

RSS

全称是Really Simple Syndication 简易信息聚合, 在一个软件中可以看到所有订阅网址更新内容.

2. 为什么会有RSS

没有RSS, 如果你要A B C D网站信息, 需要一个个上去看看有没有更新, 这样无疑很费时

如果有软件能订阅你感兴趣的A B C D网站, 只用在一个软件查看就看到4个网站的更新内容, 这就是RSS重要作用了

3. 苹果iPhone 和安卓Android RSS 应用.

iPhone

Netnewswire (不需要的默认订阅可以删除)

Android

Read

4. 一些RSS订阅网站, 写独立博客人变少了…

阮一峰 https://www.ruanyifeng.com/blog/

https://feeds.feedburner.com/ruanyifeng

陈浩 coolshell.cn

https://coolshell.cn/feed

少数派 sspai.com

https://sspai.com/feed

Dash Mac下最好的开发文档 Li.021

Thu, 29 Jul 2021 21:59:53 +0800

1. Dash 是什么

Dash 是Mac开发文档集合, 从前端React到后端Java, 能想到的语言文档这里都有

Dash 支持多种插件, 在开发工具内就可以直接搜索开发文档

Dash插件支持编辑器

官网下载 , 或使用Homebrew命令安装

brew install dash

购买-微信小店

2. 常用软件示例

2.1 Alfred

不用打开Dash软件, 使用Alfred直接搜索开发文档

Dash Wrokflow下载

搜索Dash软件java开发文档

2.2 Intellij IDEA

使用⌘ + shift + h搜索选中内容

Intellij 插件应用市场就可以下载

⌘ + shift + h 搜索选中内容

2.3 Visual Studio Code

Dash插件可以Visual Studio Code扩展市场搜索下载

option + h 指定搜索文档

option + h,指定搜索html: a标签

指定开发文档名称在Dash中可查询, 也可以自行修改

指定开发文档名称在Dash中可查询, 也可以自行修改

3. devdocs.io 在线版的, 同样好用

Alfred Mac效率神器 Li.020

Wed, 28 Jul 2021 00:45:21 +0800

1. Alfred 是什么.

Alfred是Mac上一款效率软件, 有着剪切板历史记录,快速复制之前的记录

可以快捷搜索文件, 快速打开应用或文件.

有着Snippet片段, 可以记录代码或常用的信息.

可以开发定制工作流, 完成更多复杂内容.

Alfred 安装, 官网下载 , 或使用 Homebrew 安装. 代购-微信小店 .

brew install alfred

Alfred 还需要Mac OS系统中文件夹等权限

授予Alfred权限

2. Alfred Mac效率神器.

2.1 剪粘板历史记录.

快速粘贴历史复制记录, 支持图片, 最长记录3个月时间.

快捷键⌘ + .触发, 保存最长3个月记录

⌘+.触发,搜索'复制',⌘+6 可直接粘贴历史记录到输入框

⌘+.触发,可以预览已复制图片,回车可粘贴到输入框

2.2 Snippets代码片段.

记录代码片段, 常用邮箱链接等

记录代码块, 关键字就触发粘贴, ⌘ + .或 shift + ⌘ + . 也可搜索

片段Snippets设置

html5设置参数

html5设置

Name:
html5

Keyword:
#html5

Snippet:
<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width">
        <title></title>
        link
    </head>
    <body>
        body
    </body>
</html>

关键字 ⌘ + .或 shift + ⌘ + . 也可搜索

常用邮箱等

常用邮箱配置

打出testmail自动替换为mail@lizicai.com

2.3 计算器

直接进行各种计算

计算器计算结果复制到剪切板上

2.4 工作流Workflows

开发强大的工作流, 更快速处理信息

分享几个常用的Alfred Workflows

全部Wrokfows下载

Github Workflow

快速跳到自己的Github项目, 或在Github中搜索. 使用前需要授权

Github Workflow下载

快速跳到自己的Github项目, 或在Github中搜索

链接地址编码转换Encode Decode

分享出去链接有中文通常是%AF%这样, Decode后就会显示与浏览一样的地址

Alfred Encode Decode Workflow下载

dc解密编码 ec加密编码

Dash Wrokflow

不用打开Dash软件, 使用Alfred直接搜索开发文档

在Dash软件设置里可以添加Dash Workflow

搜索Dash软件java开发文档

指定搜索引擎

搜索引擎百度谷歌必应搜狗 360搜索

Search Wrokflow 下载

百度, 搜索, 最下面一行关键词b

购物网站搜索

京东淘宝天猫亚马逊日亚美亚当当搜索

Search-goods Wrokflow下载

jd 关键字跳转京东搜索

TerminalFinder Workflow

复制访达Finder路径在终端打开, 使用达打开终端当前路径

ft: 复制访达Finder当前路径 在终端Terminal打开
tf: 复制终端Terminal当前路径 在访达Finder中打开
fi: 复制访达Finder当前路径 在终端iTerm2打开
if: 复制终端iTerm2当前路径 在访达Finder中打开

TerminalFinder Workflow 下载

tf 打开terminal文件夹在访达Finder中

exchange rate 汇率

设置本币为人民币, 就可以计算汇率了

Alfred-currency-conversion Workflow下载

需要安装node

brew install node

设置本币, curcon关键字可以计算转换汇率后金额

Translate Workflow

打开百度翻译中英文谷歌翻译

Translate Workflow 下载

fanyi关键词使用百度翻译

2.5 文件文件夹搜索

关键词’ 空格 open, 搜索文件与文件夹并打开

搜索并打开文件

搜索并进入文件夹

2.6 控制Mac OS系统快捷命令

# 退出应用
quit
# 退出全部应用
quitall
# 隐藏应用
hide
# 清空垃圾桶
emptytrash
# 锁屏
lock
# 关机
shutdown
# 重启
restart

清空垃圾桶退出(可使用⌘+5快速退出) 强制退出

2.7 使用Mac OS 字典

中文英文意思查询

dt查询

2.8 快捷运行终端terminal命令

关键词 > 触发

>运行终端Terminal命令

ZV-E10索尼2021年7月27日22点发布的新机 Li.019

Tue, 27 Jul 2021 22:26:42 +0800

SONY ZV-E10

1. ZV-E10 使用APS-C传感器, 作为对比ZV 1使用1英寸传感器.

尺寸大了3倍, APS-C(23.6mm*15.6mm)/1英寸(13.2mm*8.8mm)=3.17

ZV-E10 对比 ZV 1传感器尺寸

2. ZV-E10镜头使用E卡口, 意味超过60组原厂镜头可用, 副厂也有适马腾龙

3. ZV-E10使用与全画幅一样的数字音频热靴Mi接口, 直接使用ECM-W2BT麦克风

4. ZV-E10支持S-Log3

5. 可以用作视频会议, 支持USB type c接口.

6. 其他改进

更好的肤色表现

更好的麦克风, 防风性能更好

改进的产品展示功

表现更好的电子视频防抖

acme.sh命令 Li.018

Tue, 27 Jul 2021 14:16:36 +0800

1. acme.sh 常见命令

# 查询所有命令
acme.sh -h

# acme.sh更改申请证书机构
acme.sh --set-default-ca  --server  letsencrypt

# http方式申请证书, lizicai.com域名, --webroot指定访问文件夹
acme.sh  --issue  -d lizicai.com --webroot /root/test/

# 手动dns申请证书
acme.sh --issue --dns -d lizicai.com

# 使用dns提供接口, 自动dns申请证书, 以阿里云为例
export Ali_Key="Ali_Key"
export Ali_Secret="Ali_Secret"
acme.sh --issue --dns dns_ali -d lizicai.com

# Cloudflare 为例
export CF_Key="你的Global API Key"
export CF_Email="注册Cloudflare邮箱"
acme.sh --issue --dns dns_cf -d \*.lizicai.com


# 检查并更新所有证书
acme.sh --cron

# 设置更新证书通知, 以钉钉 dingtalk通知为例
export DINGTALK_WEBHOOK='复制的Webhook'
export DINGTALK_KEYWORD=acme
acme.sh  --set-notify  --notify-hook dingtalk

# 设置通知级别
#  --notify-level <0|1|2|3>
# Set the notification level:  Default value is 2.
# 0: disabled, no notification will be sent. 没有通知
# 1: send notifications only when there is an error. 有错误时才通知
# 2: send notifications when a cert is successfully renewed, or there is an error. 证书更新成功或错误才通知.
# 3: send notifications when a cert is skipped, renewed, or error. 跳过证书, 更新证书, 错误都有通知.
export NOTIFY_LEVEL='3'

# 设置acme.sh 自动升级
acme.sh --upgrade --auto-upgrade 1

# 卸载acme.sh, 并删除所有acme.sh添加crontab任务.
acme.sh --uninstall

# 证书key和fullchain另存, 在获取证书时一起使用
--key-file /root/cert/lizicai.com/private.key
--fullchain-file  /root/cert/lizicai.com/fullchain.pem

# 获取证书时使用, 可执行的一些命令
--reloadcmd     "/usr/sbin/nginx -s reload"

# 重新获取证书, 获取证书时使用
-r, --renew

# 强制
-f

2. 具体使用可参考acme.sh获取证书crontab更新及更新通知

acme.sh获取证书设置crontab定时检查更新及更新通知 Li.017

Mon, 26 Jul 2021 20:59:57 +0800

1. acme.sh 是什么

1.1 一个纯粹用Shell（Unix shell）语言编写的ACME协议客户端. 支持shell就能安装.

1.2 支持非盈利证书颁发机构 letsencrypt.org , 可以自由获取免费证书.

1.3 可以自动更新证书.

1.4 支持主流的DNS服务商(DNSPod.cn(腾讯旗下) 阿里云 Cloudflare GoDaddy Amazon), 可申请通配符的证书. 全部DNS服务商支持列表

1.5 支持每次更新证书时发送通知, 支持主流QQ Dingtalk钉钉 Telegram Email Slack, 完整支持列表

2. 安装acme.sh, 设置默认证书分发机构为letsencrypt.org.

2.1 安装acme.sh

curl https://get.acme.sh | sh -s email=my@example.com

2.2 设置默认证书分发机构为letsencrypt.org, 原因非盈利机构letsencrypt目前为止比较安全. ZeroSSL则是商业机构. 更多解释 .

acme.sh --set-default-ca  --server  letsencrypt

3. 申请证书常用方式. http和dns方式.

3.1 http方式, 特点简单易操作.

以Nginx为例, 配置的文件夹/root/test/

在default.conf增加配置

server{
    listen 80;
    server_name lizicai.com;
    location / {
        root   /root/test/;
        index  index.html index.htm;
    }
}

确认lizicai.com 解析a记录指向服务器ip

在域名服务商或DNS服务商增加lizicai.com指向服务ip的a记录.

检查

ping lizicai.com

预期显示服务器ip

如未显示, DNS服务商生效a记录需要时间5分钟~3小时

以http方式申请lizicai.com证书

# 与前面nginx创建的文件夹目录一致
acme.sh  --issue  -d lizicai.com --webroot /root/test/

申请证书成功则存放在 ~/.acme.sh/lizicai.com 目录下.

3.2 dns自动获取证书, 需要转移域名到支持自动获取的api的dns服务商, dnspod 阿里 Cloudflare已支持.

阿里云

登录阿里云, 获取key和secret

export Ali_Key="Ali_Key"
export Ali_Secret="Ali_Secret"

acme.sh --issue --dns dns_ali -d lizicai.com

以dnspod为例

你需要先登录到DNSPod账号, 更改域名dns服务为DNSPod, 然后生成你的api id和api key, 完全免费

export DP_Id="1234"
export DP_Key="sADDsdasdgdsf"

# 可以一次申请2个
acme.sh   --issue   --dns dns_dp   -d lizicai.com  -d www.lizicai.com
# 也可以申请通配域名, * 需要转译
acme.sh   --issue   --dns dns_dp   -d \*.lizicai.com

以Cloudflare为例

注册Cloudflare, 更改dns服务为Cloudflare, 我的个人资料->API令牌->查看Global API Key

export CF_Key="你的Global API Key"
export CF_Email="注册Cloudflare邮箱"

acme.sh --issue --dns dns_cf -d \*.lizicai.com

3.3 手动dns, 不需要转移dns服务商, 但是需要手机添加txt记录.

# 根据提示添加记录即可
acme.sh --issue --dns -d lizicai.com

4. 设置crontab定期更新证书

4.1 创建crontab的任务.

Crontab用法, 更多请参考 Crontab使用

添加如下内容, 每月1,15号12点1分钟检验证书,如距离过期<30天, 则自动申请新证书. ${HOME}安装acme.sh的home目录

vim test.cron 添加如下内容

1 12 1,15 * *  ${HOME}/.acme.sh/acme.sh --cron

4.2 任务添加到任务中.

crontab -uroot test.cron

# 检查是否添加成功
crontab -uroot -l

5. 每次更新证书获取更新通知, 了解域名更新成功或失败情况, 有问题及时处理.

网站如果使用HSTS策略, 证书过期巨大影响, 有必要第一时间获知解证书更新情况.

5.1 以Dingtalk钉钉为例. 创建钉钉test群.

钉钉Dingtalk设置

创建群test,并点击设置

选择智能群助手

添加机器人

选择自定义

添加

自定义关键词 . 或 acme 都可

复制Webhook

在acme.sh设置参数

export NOTIFY_LEVEL='3'
export DINGTALK_WEBHOOK='上面复制的Webhook'
export DINGTALK_KEYWORD=acme

设置通知为钉钉Dingtalk

acme.sh  --set-notify  --notify-hook dingtalk

设置成功后通知

更新证书时就有通知了

acme.sh --cron

更新证书时的通知

5.2 telegram通知.

@BotFather 申请机器人, /newbot 可获取TELEGRAM_BOT_APITOKEN

@userinfobot 输入 /start 可获取 TELEGRAM_BOT_CHATID

export NOTIFY_LEVEL='3'
export TELEGRAM_BOT_APITOKEN="..."
export TELEGRAM_BOT_CHATID="..."

acme.sh --set-notify --notify-hook telegram
# 测试
acme.sh --cron

SQL基本用法二 Li.016

Mon, 26 Jul 2021 00:10:53 +0800

1. 创建表

create table if not exists usrinfo(
id INT(11),
number INT(11),
name VARCHAR(255),
 birthday DATE
  );

2. 查询表结构

show full columns from usrinfo;

desc usrinfo;

describe usrinfo;

3. 查询创建表的语句

show create table usrinfo;

4. 插入数据

4.1 插入单选数据

insert into usrinfo values (12123123,"hello","1990-02-15");

4.2 插入多行数据

insert into usrinfo values (12123123,"hello","1990-02-15"),
(12123123,"cc","1991-03-01");

4.3 插入某些列

insert into usrinfo(number,name) values (121234123,"eefef");

4.4 插入某些列多行

insert into usrinfo(number,name) values (121234123,"eefef"),
(121234123,"eefef");

5. 查询某一列不重复的值

select distinct number from usrinfo;

6. 增加新的列

6.1 增加新列

alter table usrinfo add id int(11);

6.2 并给修改新列的属性

alter table usrinfo change id id int not null auto_increment primary key;

6.3 更改新加列的排序:

把id这列,放到第1列

alter table usrinfo modify id int(11) first;

6.4 把birthday这列放在number后面

alter table usrinfo modify birthday date after number;

7. 重命名表和列名.

7.1 更改表名

alter table <old_name>  rename <new_name>;

7.2 更改列名,后面必须有属性值,才能修改成功

alter table usrinfo change id new_id int(10) ;

7.3 更改列名+ 属性,由int 转换为varchar

alter table usrinfo change id new_id varchar(11);

8. 删除列.

8.1 提前新建一个列 alter table usrinfo add dd varchar(11);

mysql适用于下面的语句, 别的数据库未知.

alter table usrinfo drop dd;

9. 删除某个列中某行为null的数据,注意是is null 不是=null

delete from usrinfo where birthday is null;

10.删除一个表

为了删除我先创建一个表create table del(id int(11) not null primary key auto_increment,name varchar(255),phone int(11));

drop table del;

11. 返回唯一不同的值

11.1 查询单行的唯一不同的值

select DISTINCT birthday from usrinfo;

11.2 查询多行唯一不同的值,组合起来是唯一不同的值

select DISTINCT number,birthday from usrinfo;

12. where的简单查询语句

12.1 In 和 like

select * from usrinfo where name in ("Hello");

select * from usrinfo where name like '%ello';

%表示多个字符,_ 下划线表示一个字母,like不区分大小写的

12.2 binary 区分大小写

select * from usrinfo where name like binary 'Hello';

13. and和or

select * from usrinfo where name='hello' and number='1233';
select * from usrinfo where name='hello' or name='Hello';
select * from usrinfo where name='hello' or number=1233;

14. order by

14.1 升序,默认方式也是这种

select * from usrinfo order by number asc;

14.2 降序

select * from usrinfo order by number desc;

15. update

15.1 update 记录

update usrinfo set number=999 where id=18;
update usrinfo set number=999 wehre id in(18,19);

更新必须带where,否则会更新所有数据

16. limit

16.1 查询数据库中从2行到后n行的数据

select * from usrinfo limit 2,n;

16.2 查询起始后n行数据,如顶部的5行数据.

select * from usrinfo limit 5;

17. Min 和 Max

17.1 查询某列的最小值并赋值给参数

select min(id) as small_id from usrinfo;
select max(id) as max_id from usrinfo;

18. count计算搜索得到的行数, sum求合 avg求平均值

18.1 sum 和 avg 仅针对所有int数据

select count(id) from usrinfo;

select avc(number) from usrinfo;

19. alias 重命名

19.1 MySQL中语句

select id,CONCAT(name,' , ',address) as cc from usrinfo;

19.2 其它数据库写法

select id,name,' , ', address as cc from usrinfo;

20. inner join, left join, rigth join, full join

20.1 Mysql not have full,jush left join union right join.

默认为join为inner join两个表的交集, left join 取左边表的集合包括交集但不包含右表没有交集的部分,

右连接与左连接相反,全连接是左右表的并集.

select o.id,o.name,c.id,c.number from order as o (inner) join customers as c on o.id = c.id;
select o.id,o.name,c.id,c.number from order as o left join customers as c on o.id = c.id;
select o.id,o.name,c.id,c.number from order as o right join customers as c on o.id = c.id;

20.2 全连接

select o.id,o.name,c.id,c.number from order as o right join customers as c on o.id = c.id
union
select o.id,o.name,c.id,c.number from order as o left join customers as c on o.id = c.id;

20.3 三个表inner join

select o.orderId,o.customerID,cu.costomerID,cu.costomerName,cp.CustomerID,cp.phone1 from
(orders as o join customers as cu on where o.CustomerID = cu.CustomerID)
join cphone as cp on o.CustomerID = cp.CustomerID;

21. self join

select A.CustomerName as CustomerName1,B.CustomerName as CustomerName2,A.Country
from customers A, customers B
where A.CustomerID <> B.CustomerID and A.Country= B.Country
order by A.Country;

22. union

select CustomerID from orders
union
select CustomerID from customers;

23. group by 把查询到的结果分组

23.1 以国家为组统计有多少个id

select count(c.CustomerID),c.Country
from orders as o join customers as c on o.customerID = c.CustomerID group by c.Country;

23.2 以国家为组统计有多少个id,并按照id个数排序,从小到大

select count(c.CustomerID),c.Country
from orders as o join customers as c on o.customerID = c.CustomerID group by c.Country order by count(c.CustomerID);

24. having, having是分组(group by)后的筛选条件,分组后的数据组内再筛选,where则是在分组前筛选.

24.1 以country分组,然后找个数超过1的.

select count(CustomerID) as number,Country from customers where CustomerID>1 group by Country having count(CustomerID) > 1;

25. select into, 复制表或表结构的时候, 只得到一个"外壳", clone一个躯体, 原表的主键,外键,约束,触发器,索引都不会被复制过来.

25.1 非mysql用法

select * into orders_back from orders;

25.2 mysql用法

create table orders_back (select * from orders);

25.3 复制部分列

create table order_b1(select orderId,orderDate from orders);

25.4 可以增加where语句

create table order_b2(select orderId,orderDate from orders where orderId > 123);

25.5 只复制表

create table orders_back3 (select * from orders where 1=2)

26. Insert into select, 从一个表拿数据插入另一个表中,

26.1 复制某些字段到另一个表中

insert into orders_back(orderId,customerID,orderDate) select orderId,customerID,orderDate from orders;

26.2 复制整个表到另一个表中,两张表的结构属性是一样的

insert into orders_back select * from orders;

26.3 也可以后面跟where语句进入, 筛选要复制的列

insert into orders_back select * from orders where orderId > 1;

27. 创建一个数据库, 删除一个数据

27.1 你必须有创建或者删除数据库的权限

create database mydata;

27.2 删除数据

drop database mydata;

28. 创建一个表时,列的属性的限定

NOT NULL
UNIQUE
PRIMARY KEY
FOREIGN KEY
CHECK
DEFAULT
INDEX

28.1 check

Mysql 用法

create table person(
    id int(11) primary key,
    Age int(11),
    CHECK (Age > = 18)
);

28.2 Oracle SQL server用法

create table person(
    id int(11) primary key,
    Age int CHECK (Age>=18)
        );

28.3 多个check条件, 能用mysql, oracle都可用

create tables person(
    id int primary key,
    Age int(11),
    City varchar(255),
    CONSTRAINT CHK_person check (Age>=18 and City='Shanghai')
);

28.4 增加一个check条件

alter table person add CHECK (Age>=18);

28.5 增加多个check条件, mysql oracle都可用

alter table person add CONSTRAINT CHK_personAge CHECK (Age>=18 and city='Shanghai');

28.6 删除表中一个check条件

Mysql用法

alter table person drop CHECK CHK_personAge;

28.7 orace/SQL server用法

alter table person drop CONSTRAINT CHK_personAge;

29. Default 用法

29.1 创建表的时间

create table person(
    id int(11) primary key,
    Age int,
    City varchar(255) DEFAULT 'Shanghai'
);

29.2 增加表的属性时

Mysql用法

alter table person alter City set DEFAULT 'Shanghai';

oracle用法

alter table person modify City DEFAULT 'Shanghai';

29.3 删除默认

Mysql 用法

alter table person alter City drop default;

Oracle SQL server 用法

alter table person alter COLUMN City drop default;

30. Index 索引, 聚集索引一个表最多有一个

30.1 创建一个索引和创建多个索引

create index ind_orderId on orders(orderId);
create index ind_orderid on orders(orderId, orderDate);

30.2 删除一个索引

mysql,格式是alter table table_name drop INDEX index_name;

alter table orders drop INDEX ind_orderId;

Oracle DB2

drop index index_name;

SQL server

drop index table_name.index_name;

31. Auto_INCREMENT 自动增加值

31.1 Mysql

create table person(
    id int(11) auto_increment primary key,
    age int(3)
);

31.2 SQL server

create table person(
    id int(11) IDENTITY(1,1) primary key,
    Age int(11)
);

31.3 Oracle 未知待更新

32. View 视图是原表某些列的影分身, 更改视图也就是更改原表的数据.

create VIEW view_orders_list as select orderId,orderDate from orders;

update view_orders_list set orderId=222 where orderId=22;

32.1 更新一个视图, 可以更新列的,直接在下面语句中增加就可以了.

create or replace view view_list
as
select orderId,orderDate,customerID
from orders ;

32.2 删除一个视图

drop view view_list;

33. Null Functions

select productName, unitPrice\*(unitInstock+IFNULL(unitOrder,0)) from products;
select productName, unitPrice\*(unitInstock+COALESCE(unitOrder,0)) from products;

34. Cross join 是两个表笛卡尔集

select * from orders cross join usrinfo;

35. update 与 inner join连用

35.1 oracle 中用法

update orders set orderDate="1991-02-09" where orders.customerID in(
    select customers.CustomerID from orders join customers on
    orders.customerID = customers.CustomerID;
    );

35.2 Mysql用法

update orders  as o join
(select c.customerID from orders as o join customers as c on o.customerID = c.CustomerID)
c on o.customerID = c.customerID
set o.orderDate="1990-09-08";

36. date日期查询特定year month day的人

select * from student where year(birthday)=1990 and month(birthday)=02 and day(birthday)=13;

SQL基本用法一 Li.015

Mon, 26 Jul 2021 00:05:35 +0800

1. 建立表 4个表关系

1.学生表

Student(s_id,s_name,s_birth,s_sex) –学生编号,学生姓名, 出生年月,学生性别

2.课程表

Course(c_id,c_name,t_id) – –课程编号, 课程名称, 教师编号

3.教师表

Teacher(t_id,t_name) –教师编号,教师姓名

4.成绩表

Score(s_id,c_id,s_s_score) –学生编号,课程编号,分数

-- 学生表
CREATE TABLE Student(
s_id VARCHAR(20),
s_name VARCHAR(20) NOT NULL DEFAULT '',
s_birth VARCHAR(20) NOT NULL DEFAULT '',
s_sex VARCHAR(10) NOT NULL DEFAULT '',
PRIMARY KEY(s_id)
);

-- 课程表
CREATE TABLE Course(
c_id VARCHAR(20),
c_name VARCHAR(20) NOT NULL DEFAULT '',
t_id VARCHAR(20) NOT NULL,
PRIMARY KEY(c_id)
);

-- 教师表
CREATE TABLE Teacher(
t_id VARCHAR(20),
t_name VARCHAR(20) NOT NULL DEFAULT '',
PRIMARY KEY(t_id)
);

-- 成绩表
CREATE TABLE `Score`(
s_id VARCHAR(20),
c_id VARCHAR(20),
s_score INT(3),
PRIMARY KEY(s_id,c_id)
);

1.1 插入对应的数据

-- 插入学生表测试数据
insert into Student values('01' , '赵雷' , '1990-01-01' , '男');
insert into Student values('02' , '钱电' , '1990-12-21' , '男');
insert into Student values('03' , '孙风' , '1990-05-20' , '男');
insert into Student values('04' , '李云' , '1990-08-06' , '男');
insert into Student values('05' , '周梅' , '1991-12-01' , '女');
insert into Student values('06' , '吴兰' , '1992-03-01' , '女');
insert into Student values('07' , '郑竹' , '1989-07-01' , '女');
insert into Student values('08' , '王菊' , '1990-01-20' , '女');
insert into Student values('09' , '如花' , '1991-02-15' , '女');

-- 课程表测试数据
insert into Course values('01' , '语文' , '02');
insert into Course values('02' , '数学' , '01');
insert into Course values('03' , '英语' , '03');
insert into Course values('04' , '体育' , '01');

-- 教师表测试数据
insert into Teacher values('01' , '张三');
insert into Teacher values('02' , '李四');
insert into Teacher values('03' , '王五');

-- 成绩表测试数据
insert into Score values('01' , '01' , 80);
insert into Score values('01' , '02' , 90);
insert into Score values('01' , '03' , 99);
insert into Score values('02' , '01' , 70);
insert into Score values('02' , '02' , 60);
insert into Score values('02' , '03' , 80);
insert into Score values('03' , '01' , 80);
insert into Score values('03' , '02' , 80);
insert into Score values('03' , '03' , 80);
insert into Score values('04' , '01' , 50);
insert into Score values('04' , '02' , 30);
insert into Score values('04' , '03' , 20);
insert into Score values('05' , '01' , 76);
insert into Score values('05' , '02' , 87);
insert into Score values('06' , '01' , 31);
insert into Score values('06' , '03' , 34);
insert into Score values('07' , '02' , 89);
insert into Score values('07' , '03' , 98);
insert into Score values('09', '01', 50);
insert into Score values('09', '02', 40);
insert into Score values('09', '03', 90);
insert into Score values('09', '04', 99);

2. SQL练习

查询姓"张"老师的个数

select count(t_id) from Teacher where t_name like "张%";

查询1990年出生的学生名单

select s_id, s_name from Student where year(s_birth)=1990;

查询课程编号为"02"的总成绩

select c_id,sum(s_score) as '总成绩' from Score where c_id=02;

查询选了课程的学生人数思路学生唯一, 然后再计算总数

select count(distinct s_id) as "选课人数" from Score;

查询各科成绩最高和最低的分: 以如下的形式显示: 课程ID, 最高分, 最低分

select c_id as 课程ID, max(s_score) as 最高分, min(s_score) as 最低分 from Score group by c_id;

查询每门课程被选修的学生数

select c_id, count(s_id) from Score group by c_id;

查询男生,女生人数

select s_sex as 性别, count(s_id) as 人数 from Student group by s_sex;

查询平均成绩大于60分的学生的学号和平均成绩

学号与平均成绩都在Score表中可以获取到

select s_id as 学号, avg(s_score) as 平均成绩 from Score group by s_id having avg(s_score)>60;

查询至少选修两门课程的学生学号学生学号与学生选修课程数都在Score表中

select s_id as 学号,count(c_id) as 选修课程数 from Score group by s_id having count(c_id)>=2;

查询两门以上不及格课程的同学的学号及其平均成绩

2.1 这种做法是错误的, 只计算不及格课程的平均成绩, 如果还有其他课程及格就未计算在内了

select s_id as 学号, avg(s_score)as 平均成绩
from Score
where s_score <60
group by s_id
having count(c_id)>=2;

2.2 学生学号, 学生不及格课程总数, 平均成绩都在Score表中, 但是一条语句无法查询出来,不及格条件后的平均成绩是不正确(即是不及格课程的平均成绩),不是总成绩(包含及格与不及格课程成绩).

-- 查询到不及格课程总断>2的学生
select s_id from Score where s_score<60 group by s_id having count(c_id)>2;

-- 查询学生的总成绩计算的平均成绩
select s_id,avg(s_score) as avg_score from Score group by s_id;

-- 将2表内连接起来
select s1.s_id, s2.avg_score
from
(select s_id from Score where s_score<60 group by s_id having count(c_id)>2) as s1
join
(select s_id,avg(s_score) as avg_score from Score group by s_id) as s2
on s1.s_id=s2.s_id;

2.3 这次查询不及格课程数>1的学生,学号,平均成绩.(“09号有3门课程,三门成绩(40+50+90)/3=60”, 错误做法只计算不及格成绩(40+50)/2=45)


-- 错误做法
select s_id as 学号, avg(s_score)as 平均成绩
from Score
where s_score <60
group by s_id
having count(c_id)>1;

-- 正确做法
select s1.s_id, s2.avg_score
from
(select s_id from Score where s_score<60 group by s_id having count(c_id)>1) as s1
join
(select s_id,avg(s_score) as avg_score from Score group by s_id) as s2
on s1.s_id=s2.s_id;

查询名字完全一致的学生, 统计同名人数

-- 名字, 同名人数都在表Student中
select s_name, count(s_id) as 同名人数 from Student group by s_name having count(s_id)>1;

查询每门课程的平均成绩，结果按平均成绩升序排序，平均成绩相同时，按课程号降序排列

select c_id, avg(s_score) as '平均成绩' from Score group by c_id order by avg(s_score) ASC, c_id DESC;

查询不及格课程号和学生号, 课程号从大到小排列

-- 这些不及格课程号与学生号数据都在Score表中

select s_id, c_id, s_score from Score where s_score <60;

检索课程编号为“03”且分数小于60的学生学号，结果按按分数降序排列

select s_id, s_score from Score where c_id=03 and s_score<60;

统计每门课程的学生选修人数(超过5人的课程才统计), 要求输出课程号和选修人数，查询结果按人数降序排序，若人数相同，按课程号升序排序

select c_id, count(s_id) from Score group by c_id having count(s_id)>5 order by count(s_id) DESC, c_id ASC;

查询所有课程成绩小于60分的学生的学号、姓名. 学生成绩在表Score中, 学生姓名在表Student, 内连接2个表

-- 小于60分的学生号
select s_id, s_score where s_score<60;

-- 学生姓名

select s_id, s_name from Student;

-- 通过s_id内连接2个表, 2个成绩<60分会有2条数据, 可用group by去重

select sco.s_id,s.s_name from Score as sco join Student as s on sco.s_id=s.s_id where s_score<60 group by s_id;

-- 还可以这么写
select s_id,s_name from Student where s_id in (select s_id from Score where s_score<60);

查询没有学全所有课的学生的学号、姓名

2.4 全部课程数在Course中, 学生所选课程在Score中, 学生姓名在Student中.(隐藏条件学生所学课程一定属于全部课程中的一种)

理解是学没有学全所有课程的所有学号与学生姓名(注意是所有学生)

-- 查询全部课程数
select count(c_id) from Course;

-- 查询学生学号与课程数
select s_id, count(c_id) as count_cid from Score group by s_id;

-- 查询学生学号与学生姓名
select s_id, s_name from Student;

-- 左连Student与Score表, 为什么左连接, 因为是没有学无所有课程的学生, 学生一定会有, 学生不一定有选修的课程成绩.
select s.s_id, s.s_name from
Student as s
left join
Score as sco
on sco.s_id=s.s_id
group by s.s_id
having count(c_id)<(select count(c_id) from Course);

查询出只选修了两门课程的全部学生的学号和姓名

2.5 学生选修课程数在Score表中, 学生姓名在表Student中


-- 查询学生选择课程数为2的学生
select s_id,count(c_id) group by s_id having count(c_id)=2;

-- 查询学生姓名

select s_id, s_name from Student;

-- 左连接2个表

select s.s_id, s.s_name from
Student as s
left join
Score as sco
on s.s_id=sco.s_id
group by s.s_id having count(c_id)=2;

查询课程编号为03且课程成绩在80分以上的学生的学号和姓名

2.6 学生选修课程与成绩在Score表中, 学生姓名在表Student中

-- 查询课程03,>80的学生成绩
select s_id, s_score, c_id from Score where c_id="03" and s_score>80;

-- 查询学生姓名

select s_id, s_name from Student;

-- 内连接2个表, 注意不是左右连接,有对应成绩的才检索,否则不检索
select s.s_id, s.s_name from
Student as s
join
Score as sco
on s.s_id=sco.s_id
and sco.s_score>80 and sco.c_id="03";

-- 其他写法

select s_id, s_name from Student where s_id in (select s_id from Score where s_score>80 and c_id=03);

查询课程编号为“01”的课程比“02”的课程成绩高的所有学生的学号内连接 s1同学.s_id=s2同学.s_id, s1.c_id=“01”, s2.c_id=“02”, s1.s_score>s2.s_score, 最后去重

select s1.s_id from Score s1,Score s2 where s1.s_id=s2.s_id and s1.c_id="01" and s2.c_id="02" and s1.s_score>s2.s_score group by s1.s_id;

按平均成绩从高到低，按如下形式显示: 学生ID, 有效课程数, 有效平均分

select s_id '学生ID', count(c_id) '有效课程数', avg(s_score) '有效平均分' from Score group by s_id;

使用分段[100-85],[85-70],[70-60],[<60]来统计各科成绩，分别统计各分数段人数: 课程ID和课程名称

select c.c_id, c.c_name, sum(case when sco.s_score>=85 and sco.s_score<=100 then 1 else 0 end) as '[100-85]',
sum(case when sco.s_score>=70 and sco.s_score<85 then 1 else 0 end) as '[85-70]',
sum(case when sco.s_score>=60 and sco.s_score<70 then 1 else 0 end) as '[70-60]',
sum(case when sco.s_score<60 then 1 else 0 end) as '[<60]'
from Course c  join  Score sco on sco.c_id=c.c_id group by c.c_id;

查询出每门课程的及格人数和不及格人数

select c_id,
sum(case when s_score>=60 then 1 else 0 end) as '及格人数',
sum(case when s_score<60 then 1 else 0 end) as '不及格人数'
from Score group by c_id;

查询出每门课程的及格百分数

select c_id, sco.及格人数/(sco.及格人数+sco.不及格人数)*100 as '及格百分比' from (
select c_id,
sum(case when s_score>=60 then 1 else 0 end) as '及格人数',
sum(case when s_score<60 then 1 else 0 end) as '不及格人数'
from Score group by c_id
) as sco;

查询至少有一门课与学号为“01”的学生所学课程相同的学生的学号和姓名

2.7 注意是其他学生, 应该去除自己s_id=“01"的情况

select s_id,s_name from Student where s_id in (select s_id from Score where c_id in (select c_id from Score where s_id="02") group by s_id);

-- 内连接

select s.s_id, s.s_name from
Student s join Score sco on s.s_id=sco.s_id and sco.c_id in (select c_id from Score where s_id='01') and sco.s_id<>01 group by s.s_id;;

查询和“01”号同学所学课程完全相同的其他同学的学号

2.8 注意是其他学生, 应该去除自己s_id=“01"的情况

属于的"01"学生的课程数, 应该与"01"学生的总课程数一致才算完全一致.

-- 计算"01"号学生的课程数
select count(c_id) from Score where s_id="01";

-- 计算其他学生属于"01"课程的课程数

select s_id from Score where c_id in (select c_id from Score where s_id="01") and s_id<>01 group by s_id having count(c_id)=(select count(c_id) from Score where s_id="01");

把“SCORE”表中“张三”老师教的课的成绩都更改为此课程的平均成绩

-- 查询"张三老师名字和id"
select t_id, t_name from Teacher where t_name="张三";

-- 查询张三老师的课程

select t_id, c_id from Course where t_id in (select t_id from Teacher where t_name="张三");

-- 课程分组的平均成绩

select avg(s_score) as avg_score,c_id from Score group by c_id;

-- 张三老师课程与课程分组平均成绩内连接

select t.t_id, t.c_id, sco.avg_score from
(select t_id, c_id from Course where t_id in (select t_id from Teacher where t_name="张三")) t
join
(select avg(s_score) as avg_score,c_id from Score group by c_id) sco
on t.c_id=sco.c_id;

-- 内连接得到老师和学生课程成绩和每科的平均成绩
select * from Score as ss1 join (select sco.c_id as sco_cid,sco.avg_score as sco_avg_socre from
(select t_id, c_id from Course where t_id in (select t_id from Teacher where t_name="张三")) t
join
(select avg(s_score) as avg_score,c_id from Score group by c_id) sco
on t.c_id=sco.c_id) as ss2
on ss1.c_id=ss2.sco_cid;

-- 更新上面的内连接表
update Score as ss1 join (select sco.c_id as sco_cid,sco.avg_score as sco_avg_socre from
(select t_id, c_id from Course where t_id in (select t_id from Teacher where t_name="张三")) t
join
(select avg(s_score) as avg_score,c_id from Score group by c_id) sco
on t.c_id=sco.c_id) as ss2
on ss1.c_id=ss2.sco_cid
set ss1.s_score=ss2.sco_avg_socre;

按各科平均成绩从低到高和及格率的百分数从高到低排列，以如下形式显示: 课程号，课程名平均成绩，及格百分数

-- 查询课程号与课程平均成绩
select c_id, avg(s_score) as avg_score from Score group by c_id;

-- 及格百分数

select s1.c_id, jige/all_chenji, s2.avg_score
from Score as s1
join (select sum(case when s_score >=60 then 1 else 0 end) as jige,
count(s_id)all_chenji,
avg(s_score) as avg_score,
c_id
from Score group by c_id
) as s2
on s1.c_id=s2.c_id group by s1.c_id
order by s2.avg_score ASC, jige/all_chenji DESC;

查询不同老师所教不同课程平均分从高到低显示

select t.t_name, avg(s_score) from Teacher as t
join
Course as c
on t.t_id=c.t_id
join
Score as sco
on c.c_id=sco.c_id group by sco.c_id
order by avg(s_score) DESC;

查询学生平均成绩及其名次

select s_id,avg(s_score),@curRank:=@curRank + 1
from Score s1,(select @curRank:=0) q group by s_id;

查询各科成绩前三名的记录（不考虑成绩并列情况）

待解决

查询所有学生的学号、姓名、选课数、总成绩

2.9 所有学生, 用左连接, 查到所有学生

-- 学号,姓名在Student表中, 学号,选课数,总成绩在Score表中, 左连接起来
select s.s_id, s.s_name,count(c_id),sum(s_score) from Student as s
left join
Score as sco
on s.s_id=sco.s_id
group by s_id;

查询平均成绩大于85的所有学生的学号、姓名和平均成绩

-- 学号,姓名在Student表中, 平均成绩,选课数在Score表中, 左连接起来
select s.s_id, s.s_name,avg(s_score) from Student as s
left join
Score as sco
on s.s_id=sco.s_id
group by s_id
having avg(s_score)>85;

查询有2门不同课程成绩相同的学生的学号、课程号、学生成绩

select s1.s_id,s1.c_id,s1.s_score from Score s1,Score s2
where s1.s_id=s2.s_id
and s1.s_score=s2.s_score
and s1.c_id<>s2.c_id
group by s1.s_id,s1.c_id;

查询选修了全部课程的学生信息

select * from Student where s_id in (select s_id from Score group by s_id having count(c_id)=(select count(c_id) from Course));

MariaDB MySQL连接的2种常见错误 Li.014

Sun, 25 Jul 2021 23:55:39 +0800

1. 常见MySQL Mariadb连接的2种错误

1.1 错误一

ERROR 1045 (28000): Access denied
for user 'usera'@'localhost' (using password:YES)

1.2 错误二

ERROR 1045 (28000): Access denied
for user 'usera'@'localhost' (using password:NO).

2. 错误一常见错误是密码错误

重置密码即可

3. 错误二输入账号密码时没有输入密码.

3.1 命令行中没有-p进行无密码登录

3.2 如果是IDE中的yaml文件确定password的缩进正确

cat application.yaml

spring:
  datasource:
    driver-class-name: org.mariadb.jdbc.Driver
    url: jdbc:mariadb://localhost:3306/admin
    username: admin
password: 123456

上面的password缩进错误, 就会提示(using password:No)

正确的是

spring:
  datasource:
    driver-class-name: org.mariadb.jdbc.Driver
    url: jdbc:mariadb://localhost:3306/admin
    username: admin
    password: 123456

编译安装Nginx支持tls1.3 Li.013

Sun, 25 Jul 2021 20:29:58 +0800

1. 直接脚本安装, 分别安装openss 1.1.1k和Nginx.

步骤2 3分步安装是脚本的解释. 步骤4是配置和验证.

curl -O https://raw.githubusercontent.com/leezicai/share/master/nginx/yum_install_openssl.sh
sh yum_install_openssl.sh

curl -O https://raw.githubusercontent.com/leezicai/share/master/nginx/yum_install_openssl_nginx.sh
sh yum_install_openssl_nginx.sh

2. 分步安装, 安装Opentssl, tls1.3需要openssl 1.1.1以上版本, 默认CentOS中openssl版本1.1.1以下, 不支持.

install_openssl.sh


# 安装需要编译的软件
yum install -y gcc gcc-c++ pcre-devel zlib-devel make unzip gd-devel perl-ExtUtils-Embed libxslt-devel openssl-devel perl-Test-Simple

yum groupinstall -y 'Development Tools'

cd /usr/src

wget https://www.openssl.org/source/openssl-1.1.1k.tar.gz

tar xvf openssl-1.1.1k.tar.gz

cp -r openssl-1.1.1k openssl

cd openssl

./config --prefix=/usr/local/openssl --openssldir=/usr/local/openssl --libdir=/lib64 shared zlib-dynamic

make -j4

make test

make install

mv /usr/bin/openssl /usr/bin/openssl-backup

ln -s /usr/local/openssl/bin/openssl /usr/bin/openssl

3. 分步安装, 编译安装Nginx, 编译安装nginx脚本

3.1 编译安装Nginx, 需要指定openssl的路径.

# 编译安装nginx
cd /usr/src

wget http://nginx.org/download/nginx-1.21.1.tar.gz

tar xvf nginx-1.21.1.tar.gz

cd nginx-1.21.1

# 使用命令nginx -V查看编译参数, 和官方源保持一致, 仅用添加--with-openssl=/usr/src/openssl即可.
./configure --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib64/nginx/modules --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --http-client-body-temp-path=/var/cache/nginx/client_temp --http-proxy-temp-path=/var/cache/nginx/proxy_temp --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp --http-scgi-temp-path=/var/cache/nginx/scgi_temp --user=nginx --group=nginx --with-compat --with-file-aio --with-threads --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_mp4_module --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-mail --with-mail_ssl_module --with-stream --with-stream_realip_module --with-stream_ssl_module --with-stream_ssl_preread_module --with-cc-opt='-O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic -fPIC' --with-ld-opt='-Wl,-z,relro -Wl,-z,now -pie' --with-openssl=/usr/src/openssl

make -j4

make install

3.2 创建Nginx服务, 参考官方

# 创建nginx服务
vi /lib/systemd/system/nginx.service

# 输入以下内容
[Unit]
Description=The NGINX HTTP and reverse proxy server
After=syslog.target network-online.target remote-fs.target nss-lookup.target
Wants=network-online.target

[Service]
Type=forking
PIDFile=/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t
ExecStart=/usr/sbin/nginx
ExecReload=/usr/sbin/nginx -s reload
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true

[Install]
WantedBy=multi-user.target

3.3 启动nginx服务, 已经支持tls1.3.

# nginx.service生效
systemctl daemon-reload

systemctl enable nginx

systemctl start nginx

4. 配置和验证tls1.3

4.1 配置支持tls1.3

在https服务中服务以下参数即可.

ssl_protocols    TLSv1.1 TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers    on;
ssl_ciphers                 TLS13-AES-256-GCM-SHA384:TLS13-CHACHA20-POLY1305-SHA256:TLS13-AES-128-GCM-SHA256:TLS13-AES-128-CCM-8-SHA256:TLS13-AES-128-CCM-SHA256:EECDH+CHACHA20:EECDH+CHACHA20-draft:EECDH+ECDSA+AES128:EECDH+aRSA+AES128:RSA+AES128:EECDH+ECDSA+AES256:EECDH+aRSA+AES256:RSA+AES256:EECDH+ECDSA+3DES:EECDH+aRSA+3DES:RSA+3DES:!MD5;

配置后重启nginx
systemctl restart nginx

4.2 浏览器中查看tls版本.

Google Chrome浏览器添加Security即可查看

安装Nginx可用服务 Li.012

Sun, 25 Jul 2021 17:08:50 +0800

1. Nginx 简介, 本篇主要Nginx安装.

Nginx是免费的开源软件，根据类BSD许可证的条款发布。

Nginx是异步框架的网页服务器，也可以用作反向代理、负载平衡器和HTTP缓存。

根据W3Techs的数据，前100万个网站中的37.7%，前10万个网站中的49.7%，以及前10000个网站中的57.0%被使用.

2. Nginx 安装.

2.1 CentOS 使用默认源安装

yum install nginx

2.2 CentOS 使用Nginx官方源安装, 安装脚本地址 .

创建Nginx官方源

vim /etc/yum.repos.d/nginx.repo

# 存入写下面数据

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

使用yum安装nginx

# 默认安装 最新稳定版本nginx.
yum install nginx

检查安装成功

nginx -version

2.3 如需编译安装可参考, 编译安装Nginx地址 .

3. 创建Nginx可访问的服务, 开通端口. 仅安装Nginx外部仍然是无法访问的, 需要解决如下问题.

3.1 云服务器开启安全组, 对外网开放可以访问的端口和协议. 以腾讯云为例添加Nginx的80和443端口.

云服务商有无安全组, 蓝色有, 灰色标记无

类型	腾讯云	阿里云	亚马逊云	谷歌云	搬瓦工
有无安全组

以腾讯为例如何开通安全组中 80 和 443 端口.

点击对应的云服务

云服务中查看安全组名称, 及有无80和443端口

选择服务器使用的安全组, 修改规则

自定义 0.0.0.0/0 TCP:80,443 允许 ok

增加80和443商品

3.2 关闭SElinux.

为何关闭SELinux

SELinux有着变态的限制系统服务，文件权限，网络端口访问, 哪怕root用户也不行.

除资深Linux 安全用户, 否则不建议开启.

CentOS 发行版有安装SELinux, Ubuntu是未安装SELinux, 真的必须的吗?

永久关闭SELinux

vi /etc/selinux/config

# 更改为 disabled
SELINUX="disabled"

重启电脑

reboot

检查SELinux状态

getenforce

输出预期是disabled.

3.2 开启防火墙80和443端口, 以CentOS为例.

# 启动防火墙
systemctl start firewalld
# 添加80 和 443 端口
firewall-cmd --zone=public --add-port=443/tcp --permanent
firewall-cmd --zone=public --add-port=80/tcp --permanent
# 重启防火墙, 生效添加的端口.
systemctl restart firewalld

补充查询占用80或443端口, 如占用, 可关闭占用程序.

netstat -tunlp | grep 80
netstat -tunlp | grep 443
kill -9 5970

关闭占用的端口

4. 启动Nginx服务, 浏览器访问.

4.1 启动Nginx服务, 并设置开机启动.

# 启动
systemctl start nginx
# 设置开机自启动
systemctl enabled nginx

4.2 浏览器访问ip, 检查Nginx启动成功.

访问服务器所在的ip即可.

出现类似这样的页面表示Nginx服务已可用

安装MariaDB和设置utf-8mb4字符集 Li.011

Wed, 21 Jul 2021 01:01:19 +0800

1. 安装MariaDB. 二种方式, 使用默认源和自建官方源.

1.1 使用默认源

yum -y install mariadb-server mariadb-client

安装后执行, mysql_secure_installation是初始化

systemctl enable mariadb
systemctl start mariadb
mysql_secure_installation

1.2 使用自建官方源, 可安装MariaDB 10.5稳定版. 官方文档地址

创建MariaDB.repo

vim /etc/yum.repos.d/MariaDB.repo

# MariaDB 10.7 CentOS repository list - created 2022-02-16 06:02 UTC
# https://mariadb.org/download/
[mariadb]
name = MariaDB
baseurl = https://tw1.mirror.blendbyte.net/mariadb/yum/10.7/centos7-amd64
gpgkey=https://tw1.mirror.blendbyte.net/mariadb/yum/RPM-GPG-KEY-MariaDB
gpgcheck=1

再执行安装命令即可, 并初始化

yum install -y mariadb-server mariadb-client
systemctl enable mariadb
systemctl start mariadb
# 初始化
mysql_secure_installation

2. 设置MariaDB字符集. 需要设置1个文件my.cnf 即可

2.1 vim /etc/my.cnf 增加以下内容

[client]
default-character-set = utf8mb4

[mysql]
default-character-set = utf8mb4

[mysqld]
character-set-client-handshake = FALSE
init_connect='SET NAMES utf8mb4'
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci

!includedir /etc/my.cnf.d

character-set-client-handshake=FALSE 可以影响collation_connection的结果为utf8mb4_unicode_ci，而不是utf8mb4_general_ci。当然，使用SET collation_connection = utf8mb4_unicode_ci或collation_connection = utf8mb4_unicode_ci也可以。
SET NAMES 指示客户端连接使用的字符集，即向服务器发送 SQL 语句的字符集。 character-set-server 设置服务器字符集。要正确使用 utf8mb4，需要确保客户端、服务器和连接都设置为 utf8mb4。
init_connect等所有其他有关字符集的默认设置都会继承自character-set-server，也即单独指定init-connect、character_set_client, character_set_results,character_set_connection等都是不必须的。因此，上面设置中的init_connect可以省略

3. 重启MariaDB, 连接数据库,检查字符集.

3.1 重启MariaDB

systemctl restart mariadb

3.2 连接数据库.

# 回车输入密码即可
mysql -uroot -hlocalhost -P3306 -p

3.3 检查字符集

show variables like '%character%';
show variables like '%collation%';

4. 补充utf8mb4_unicode_ci和utf8mb4_general_ci区别, MySQL可以使用utf8mb4_0900_ai_ci, character_set_system是固定utf8不可更改.

4.1 utf8mb4_unicode_ci和utf8mb4_general_ci区别

utf8mb4_unicode_ci: 基于标准的Unicode来排序和比较，能够在各种语言之间精确排序，在特殊情况下，Unicode排序规则为了能够处理特殊字符的情况，实现了略微复杂的排序算法，所以兼容度比较高，但是性能不高。

utf8mb4_general_ci: 没有实现Unicode排序规则，在遇到某些特殊语言或者字符集，排序结果可能不一致，但是在比较和排序的时候速度更快。

4.2 MySQL可以使用utf8mb4_0900_ai_ci, 对应位置替换,show variables like ‘%character%’;与MariaDB一致,show variables like ‘%collation%’;

collation_connection          utf8mb4_0900_ai_ci
collation_database            utf8mb4_general_ci
collation_server              utf8mb4_0900_ai_ci
default_collation_for_utf8mb4 utf8mb4_0900_ai_ci

查询结果

character_set_system固定utf8格式, 不可更改.

参考 MariaDB官方支持字符集

创建用户和授权, 远程访问%

CREATE DATABASE testdatabase;
CREATE USER 'testuser'@'%' IDENTIFIED BY 'password';
# mariadb mysql.user view
SET Password FOR root@'localhost' = password('password');
GRANT ALL ON testdatabase.* TO 'testuser'@'%';
FLUSH PRIVILEGES;

5. 修复优化所有数据库中所有表

mysqlcheck -u root -p --auto-repair --optimize --all-databases

Crontab定时任务使用 Li.010

Wed, 21 Jul 2021 00:48:32 +0800

1. 使用Crontab的原因.

每次更新博客都要登录服务器(ssh延迟容易中断)手动去拉取代码, 不方便. 故设置成自动获取最新代码.

2. 选择crontab定时

查看下资源, 觉得crontab简单可行, 直接来用就好了.

3. 定时任务需需要做事情.

特定目录执行git pul的shell脚本. 这里配置ssh key

vim git_pull.sh


#!/bin/bash

# 进入目录中

cd ~/nginx-hugoBlog/lizicai.com/

# 拉取github中的代码

git pull

添加crontab任务文件

vim git_pull.cron

设置5分钟拉取一次代码

*/5 * * * * cd /root && ./git_pull.sh

把定时任务文件内容加到crontab中

# 添加root账户中

crontab -uroot git_pull.cron

# 查询当前任务, root是账户, 添加的定时任务会放到这个目录中
crontab -uroot -l
cat /var/spool/cron/root


# 删除root用户的定时任务

crontab -uroot -r

日志的地址, 相当重要.

# 日志文件 /var/spool/mail/root
# 查看日志
# 可以把时间设置1分钟, 可以很快看到执行情况, 方便调试.

tail -f /var/spool/mail/root

4. crontab 时间配置

# 格式是
# 分 时 月份中第日 月份 星期中第几天 运行的命令

# 每分钟执行一次,
*/1 * * * * 命令

# 每小时第20, 30分钟执行一次

20,30 * * * * 命令

# 8-20时, 每小时第20, 30分执行一次

20,30 8-20 * * * 命令

# 每2天执行一次命令
0 0 */2 * * 命令

# 周六周日执行命令
0 0 0 0 6,0  命令

# 每月初一, 十五去执行

0 0 1,15 * *  命令

Ag Fasd Fzf终端模糊搜索神器 Li.009

Tue, 20 Jul 2021 23:00:24 +0800

ag比grep快速的速度, 同时打印出搜索词的行数.

Fasd 时空机, 瞬间跳到去过的目录, 或定位打开过的文件.

Fzf 模糊搜索工具.

1. 安装ag fasd fzf

1.1 Mac安装ag fasd fzf.

brew install the_silver_searcher fzf fasd

# 以下内容添加到~/.zshrc或~/.bashrc中
eval "$(fasd --init auto)"

# 重新生效
source ~/.zshrc 或 source ~/.bashrc

1.2 Linux安装ag fasd fzf.

yum install the_silver_searcher fasd

git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf

~/.fzf/install

2. 别名

alias jan='fasd -a'        # any
alias js='fasd -si'       # show / search / select
alias jd='fasd -d'        # directory
alias jf='fasd -f'        # file
alias jsd='fasd -sid'     # interactive directory selection
alias jsf='fasd -sif'     # interactive file selection
alias j='fasd_cd -d'     # cd, same functionality as j in autojump
alias jz='fasd_cd -d -i' # cd with interactive selection
alias jdd='fasd -D' # 删除一个路径

alias v='jf -e vim'
alias nv='jf -e nvim'
alias catf='jf -e cat'
alias py3f="jf -e python3"
alias lsf="jd -e ls"
alias shf='jf -e sh'
alias commandf='jf -e command'

# preview file
alias ffp='fzf --preview '"'"'[[ $(file --mime {}) =~ binary ]] && echo {} is a binary file || (rougify {}  || highlight -O ansi -l {} || coderay {} || cat {}) 2> /dev/null | head -500'"'"

# 跳到最近匹配的目录中
jj() {
    [ $# -gt 0 ] && fasd_cd -d "$*" && return
    local dir
    dir="$(fasd -Rdl "$1" | fzf -1 -0 --no-sort +m)" && cd "${dir}" || return 1
}

jje() {
    [ $# -gt 0 ] && fasd_cd -d "$*" && return
    local dir
    dir="$(fasd -Rdl "$1" | fzf -e -1 -0 --no-sort +m)" && cd "${dir}" || return 1
}

# 从当前路径搜索并跳转
jcd() {
  local dir
  dir=$(find ${1:-.} -path '*/\.*' -prune \
                  -o -type d -print 2> /dev/null | fzf +m) &&
  cd "$dir"
}
jcde() {
  local dir
  dir=$(find ${1:-.} -path '*/\.*' -prune \
                  -o -type d -print 2> /dev/null | fzf -e +m) &&
  cd "$dir"
}

alias ffall="find / -type f | fzf | pbcopy"
alias ffm="find ~/ -type f | fzf | pbcopy"
alias ffd="find . -type f | fzf | pbcopy"
alias ffec="find ~/ -type f | fzf -e | pbcopy"

3. 使用效果

3.1 ag, ag与fasd联用.

3.2 fasd使用

单个文件夹

多个目录关键词也能识别出来

3.3 fzf 搜索命令行历史记录模糊搜索并跳转, 预览文件内容

Control + R 搜索命令行历史记录

模糊搜索并跳转

快速预览文件内容

Homebrew Mac下最好用的软件管理工具 Li.008

Mon, 19 Jul 2021 22:50:18 +0800

1. Homebrew是什么? Homebrew能做什么?

Homebrew是Mac下神一样的软件管理工具.

Homebrew几乎安装任何你想到的开源软件(没有界面Gui的, 有界面的)

Homebrew同样支持相当多的商业应用安装, 像jetbrains IDEA全家桶, 网易云音乐 QQ也都支持.

2. Homebrew 安装

打开终端Terminal, 输入下面命令即可.

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

3. Homebrew 使用.

3.1 brew install –cask与brew install合并为brew install.

brew install 可安装有界面或无界面的软件与应用.

如果重名, 仍然需要brew install –cask

# 搜索软件
brew search git
brew search google-chrome

# 安装
brew install vim
brew install neteasemusic

# 重新安装
brew reinstall vim
brew reinstall neteasemusic

# 升级软件
brew upgrade curl
brew upgrade google-chrome

# 不升级软件
brew pin curl

# 卸载软件与应用
brew uninstall git
brew uninstall  QQ

# 查看软件与应用
brew info git
brew info sourcetree
brew list

# 启动软件
brew services start mariadb

# 重新启动软件
brew services restart nginx

# 关闭软件
brew services stop mariadb

3.2 使用别名, 更快速, 下面别名写~/.zshrc或~/.bashrc中, source ~/.zshrc或.bashrc重新生效.

# Brew

alias bsearch='brew search'
alias bupdate='brew update'
alias blist='brew list'
alias boutdated='brew outdated'
alias bupout='brew update && brew outdated'
alias binstall='brew install'
alias buninstall='brew uninstall'
alias breinstall='brew reinstall'
alias bupgrade='brew upgrade'
alias bremove='brew remove'
alias binfo='brew info'

# brew services
alias bservices='brew services'
alias bstart='brew services start'
alias bsrestart='brew services restart'
alias bstop='brew services stop'
alias bslist='brew services list'

# brew cask
alias bcinstall='brew install --cask'
alias bcreinstall='brew reinstall --cask'
alias bcinfo='brew --cask info'
alias bcuninstall='brew uninstall --cask'
alias bcremove='brew remove --cask'
alias bcupgrade='brew upgrade --cask'
alias bcoutdated='brew --cask outdated'
alias bclist='brew list --cask '
alias bcask='brew --cask'
alias bcua='brew cu -a'
alias buca='brew cu -a'

3.3 查看所有有界面Gui可更新软件.

安装brew-cask-upgrade, 升级管理

brew tap buo/cask-upgrade

查看所有有界面可升级的软件

brew cu -a

选择Y更新所有, 也可brew upgrade visual-studio-code, 更新指定软件

4. (此方式Homebrew已经弃用,新的试了下也不行, 待解决)Homebrew安装指定版本的软件.

4.1 使用brew info查看软件信息

brew info vim

4.2 访问来源, https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/vim.rb

4.3 查看历史信息

4.4 显示历史信息, 点击需要安装的vim版本, 8.2.3100

4.5 根据当前系统找到对应sha256, 复制

4.6 安装, 拼接出地址, 直接安装.

brew install https://raw.githubusercontent.com/Homebrew/homebrew-core/f73c37f7282bf9c542aeba15b4ae7862cb65c757ed455594eecc5ced52bb307d/Formula/vim.rb

Oh My Zsh配置和插件终端神器 Li.007

Mon, 19 Jul 2021 21:47:33 +0800

1. Oh My Zsh是什么

Oh My Zsh是一个开源的、社区驱动的框架，用于管理zsh 配置。让天下没有难用的终端(Terminal), 终端terminal神器.

适用于Mac Linux平台.

2. Oh My Zsh安装, Oh My Zsh官网

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

3. Oh My Zsh插件, Git zsh-autosuggestions fasd zsh-syntax-highlighting 让终端起飞.

3.1 Git插件, Oh My Zsh自带, 把所有的git命令做了别名, 更快使用git命令.

在~/.zshrc中启用

plugins=(git)

# 终端内
# gb 等于 git branch
# st 等价git status
# gcmsg 等于 git commit -m
# gm 等于git merge
# gco 等于git checkout

全部别名地址

3.2 zsh-autosuggestions 显示之前运行的命令, 按<control + e>即可补全.

安装zsh-autosuggestions

zsh-autosuggestions安装官网

git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

在~/.zshrc中启用

plugins=(git zsh-autosuggestions)

重新生效

sourch ~/.zshrc

效果展示, Control + e即可补全

3.3 fasd时空机, 可以跳到任何之前去过的目录, 再也不必cd来cd去了, 可以和更多的命令连用.

fasd可以记录访问目录的权重, 常访问目录权重高, 匹配放在前面.

安装fasd

brew install fasd

初始化到~/.zshrc中, j用作fasd的别名

# 插件增加fasd
plugins=(git zsh-autosuggestions fasd)
eval "$(fasd --init auto)"
alias j='fasd_cd -d'

重新生效~/.zshrc

source ~/.zshrc

使用效果, 直接回车就可跳转, 也可使用tab依权重选择

目录关键词也能识别出来

和其他命令连用,和vim连用,vim可以在任何目录打开之前编辑过的文件

alias v='jf -e vim'
alias py3f="jf -e python3"
# 写入.zshrc中
# source ~/.zshrc生效

更多别名, 存入.zshrc中

alias jan='fasd -a'        # any
alias js='fasd -si'       # show / search / select
alias jd='fasd -d'        # directory
alias jf='fasd -f'        # file
alias jsd='fasd -sid'     # interactive directory selection
alias jsf='fasd -sif'     # interactive file selection
alias j='fasd_cd -d'     # cd, same functionality as j in autojump
alias jz='fasd_cd -d -i' # cd with interactive selection
alias jdd='fasd -D' # 删除一个路径

alias v='jf -e vim'
alias nv='jf -e nvim'
alias batf='jf -e bat'
alias catf='jf -e cat'
alias py3f="jf -e python3"
alias lsf="jd -e ls"
alias shf='jf -e sh'
alias commandf='jf -e command'

3.4 zsh-syntax-highlighting高亮显示正确的命令.

安装zsh-syntax-highlighting

zsh-syntax-highlighting官网地址

git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

在~/.zshrc中启用

plugins=(git fasd zsh-autosuggestions  zsh-syntax-highlighting)

source ~/.zshrc 生效

source ~/.zshrc

使用效果, 演示

4. Oh My Zsh 主题

主题截图演示地址

# 主题都存放在这个目录下
ls ~/.oh-my-zsh/themes/

# 在.zshrc中, 选择喜欢的主题就行.
ZSH_THEME="robbyrussell"

# 重新生效, 就能看到效果了
source ~/.zshrc

2021苹果返校季促销活动买Mac和iPad送AirPods无线耳机 Li.006

Sun, 18 Jul 2021 22:08:57 +0800

1. 谁可以购买, 购买资格, 官方参考 .

幼儿园、小学和中学 — 中国大陆的公立或私立幼儿园、小学或中学的任何雇员。

高等教育机构 — 中国大陆高校（即指公立或私立大学及专科院校）的教职工，以及在中国大陆高校就读或已被录取的学生。

高等教育机构学生的父母 — 代表目前在中国大陆高校就读或已被录取的子女进行购买的父母。

学生. 购买需要: 学⽣证或录取通知书, 和身份证(非中国居民需护照).

学生	是否有资格购买
已录取(拿到高等院校录取通知书)
在读大学生
在读大专生
在读研究生
在读博士生

教职工. 购买需要: 教职⼯证.

教职工	是否有资格购买
幼儿园老师或学校职员
小学老师或学校职员
中学老师或学校职员
大陆(公立或私立)大学教师和学校员工
大陆(公立或私立)专科院校教师和学校员工

高校学生父母. 购买需要: ⼦⼥的学⽣证或录取通知书和身份证(⾮中国居⺠需要提供护照)

父母	是否有资格购买
子女在读或已被高等院校录取

补充常见非教育优惠人群.

非教育优惠人群	是否有资格购买
幼儿园学生小学生初中生高中生
培训机构机构教职工

2. 优惠时间.

2021年7月16日 ~ 2021年9月27日

3. 购买渠道

3.1 线上渠道, 适用所有人.

Apple官网教育商店

天猫 Apple Store官方旗舰店

致电 400-666-8800

3.2 线下渠道, 所在城市已有Apple Store 零售店.

4. 哪些产品购买可赠送AirPods耳机, Mac(全部型号)和iPad(部分型号).

Mac 全部型号, iPad部分型号可赠送Airpods(二代).

M2芯片的MacBook大概10月发布了, 预算充足可以再等等.

Mac或iPad型号	教育优惠限购类型	教育优惠限购数量
MacBook Pro 13或16寸	笔记本电脑	每年可购买 1 台
MacBook Air	笔记本电脑	每年可购买 1 台
Mac mini	Mac mini	每年可购买 1 台
Mac Pro	台式电脑	每年可购买 1 台
iMac 24或27寸	台式电脑	每年可购买 1 台
iMac Pro	台式电脑	每年可购买 1 台
iPad Pro	iPad	每年可购买 2 台
iPad Air	iPad	每年可购买 2 台
iPad	iPad	每年可购买 2 台
iPad mini	iPad	每年可购买 2 台

不同类别可以同时购买同样有教育优惠, 买一台MacBook Pro和一台iPad Pro都有教育优惠, 但仅送一次耳机

同一教育优惠限购类型有数量限制, 如iPad限购2台, iPad和iPad mini同样会占用数量, 超出数量部分无法参加活动, 也没有教育优惠

在线查找城市零售店

完整城市零售店

5. 比较有"性价比"的配件.

5.1 AirPods可以加700元左右即可升级赠送AirPods Pro(降噪耳机)

5.2 Final Cut Pro,Logic Pro五件套仅需要1298元, 官网购买地址

共有Final Cut Pro, Logic Pro, Motion, Compressor, MainStage 五款优秀的视频和音乐制作软件.

想学习制作视频和音乐不要错过

也可以过段时间购买, 软件优惠一直有的.

5.3 Apple Care, 购买同样有教育优惠价格.

5.4 Apple Pencil(第二代), 教育优惠价格895, 无教育优惠价格969.

6. 附录完整图片.

acme.sh被收购更换默认证书颁发机构为ZeroSSL 还安全吗? Li.005

Sun, 18 Jul 2021 00:03:06 +0800

1. acme.sh是什么.

1.1 acme.sh是实现ACME (自动证书管理环境 - Automatic Certificate Management Environment) 的客户端, ACME由 Let’s Encrypt 实现的协议。与该协议兼容的软件可以用它与 Let’s Encrypt 通信以获取证书.

1.2 acme.sh被ZeroSSL商业收购, acme.sh更改默认申请证书的服务商为ZeroSSL.

1.3 收购关系图, 被收购管理上复杂, 意味暴露信息更扩散, 更多的人有有这些数据权限.

2. 先说下我的观点.

开源都是爱发电的, 真的是用爱发电

开源能够商业收购, 即了不起也是幸运的事情, 毕竟内卷时代, 为爱发电, 又能获得收入实属难得

2021年7月21日, 官方文档中已明确说明默认证书申请机构是ZeroSSL(在这之前没有明确说明)

3. 为什么acme.sh更换默认证书颁发机构影响如此大.

3.1 使用acme.sh客户端申请证书人数众多

3.2 大部分用户翻墙科学上网就是使用这个acme.sh客户端申请证书.

3.3 每次申请证书暴露用户的信息.

	申请服务器的IP	申请SSL证书的域名	域名DNS指向的IP
acme.sh & ZeroSS

4. 暴露这么多信息, 会怎样?

4.1 目前想到比较紧急的

科学上网变得更不安全了, 商业公司的数据可能说卖就卖了, 被收购

那些使用CloudFlare 代理的用户也不再安全, 在申请证书时就暴露自己IP地址了

4.2 避免的信息暴露一些方式

立即更改默认证书颁发机构为letsencrypt

acme.sh --set-default-ca  --server  letsencrypt

更换其他实现acme(自动证书管理环境)的客户端

如Certbot

使用CloudFlare代理的用户, 在CloudeFlare和个人服务器之间使用自签证书

Hugo和GitHub Pages搭建静态网站 Li.004

Fri, 16 Jul 2021 10:58:24 +0800

Hugo是一个用Go 编写的静态网站生成器.

GitHub Pages是GitHub提供的一个网页寄存服务，于2008年推出。可以用于存放静态网页，包括博客、项目文档甚至整本书.

Hugo和Github Pages组合就可以免费创建博客网站.

本篇文章属于Hugo学习路线Li.028一部分

1. 安装Hugo, Hugo仅需一个可执行文件, Hugoe支持Windows Mac Linux平台.

1.1 Windows安装.

创建三个文件夹

创建一个新的文件夹，D:\Hugo。

创建一个新的文件夹，D:\Hugo\bin。

创建一个新的文件夹，D:\Hugo\Sites。

下载Hugo执行文件, 解压存放到D:\Hugo\bin\中

下载Windows版本的 Hugo

解压出文件, 文件复制到D:\Hugo\bin中.

把PATH=PATH%;D:\Hugo\bin添加到Windows环境变量中

检查正确运行

打开Power Shell

hugo version

显示hugo版本就是正常.

1.2 Mac直接使用brew install hugo, Brew安装 .

brew install hugo

1.3 linux下载文件并移动到/usr/local/bin/下即可, Mac也可以使用这种方式(Hugo版本Mac OS).

下载Linux 64版本Hugo

Hugo下载地址

解压出hugo文件,移动hugo到/usr/local/bin/文件下

# 以0.85版本为例
wget https://github.com/gohugoio/hugo/releases/download/v0.85.0/hugo_0.85.0_Linux-64bit.tar.gz
tar xvf hugo_0.85.0_Linux-64bit.tar.gz
mv hugo /usr/local/bin/

检查正确运行

hugo version

显示hugo版本就是正常.

2. 使用Hugo, 创建静态网站.

2.1 创建静态网站文件夹

cd ~
hugo new site mywebsite

2.2 写第一篇markdown文章

markdown语法参考

cd ~/mywebsite
hugo new posts/test.md

生成的readme.md是放在~/mywebsite/content中

2.3 打开content/readme.md添加内容

添加内容"我写的第1篇文章"

更改draft: true 为 draft:false

2.4 启动hugo服务

cd ~/mywebsite
hugo server

跳转到 http://localhost:1313 即可预览.

3. 下载使用 Hugo Theme(主题)

3.1 下载主题, 在~/mywebsite下载存放到themes文件夹中.

cd ~/.mywebsite
git clone git@github.com:leezicai/hugo-PaperMod.git themes/papermod

3.2 使用主题, 预览.

cd ~/mywebsite
# 关闭上一个预览程序control + c
hugo server --theme=papermod

跳转到 http://localhost:1313 即可预览.

4. 创建GitHub项目mywebsite

在GitHub中创建test的public公共类型项目. 创建完后访问地址https://github.com/leezicai/mywebsite

5. 生成本地静态网站, 并推送到Github的mywebsite.

5.1 Hugo命令生成静态网页

注意baseUrl后的地址是HTTPS的类型, github pages强制https类型

baseUrl的结束有/

mywebsite注意大小写

cd ~/mywebsite
hugo --theme=papermod --baseUrl="https://leezicai.github.io/mywebsite/" --destination=mywebsite

这里会生成文件到mywebsite文件夹下.

5.2 初始化并推荐送到Github.com上.

cd ~/mywebsite/mywebsite

git init

git remote add github git@github.com:leezicai/mywebsite.git

git config user.email "test@test.com"

git config user.name "leezicai"

git add .

git commit -m "init"

git push -u github master:master

6. Github进入mywebsite, 设置GitHub Pages.

6.1 进入,以我的项目setting设置里

https://github.com/leezicai/mywebsite

设置->Pages

选择Source为master即可

Theme Chooser必须要选择一个主题, 否则404

7. 查看GitHub Pages.

刷新进入https://github.com/leezicai/mywebsite/settings

设置->Github Pages下, 看到你的网站地址.

https://leezicai.github.io/mywebsite/

8. 图片链接.

8.1 相对路径引入图片.

图片和test.md同一层时, hugo生成静态博客时test.md会生成文件夹,图片就成了test.md的上一层文件夹中, ../表示在上一层目录

本地和Github Pages相对路径不一致, 本地同样不显示

mv Alexey-Sviridkin-VXb42m0uM3s.jpg ~/mywebsite/content/posts/
![cat](../Alexey-Sviridkin-VXb42m0uM3s.jpg)

8.2 使用根目录引入图片.

~/mywebsite/static/

相对路径, mywebsite与github pages的项目名一致 本地是无法显示图片的, 因为本地和Github Pages地址不一致, Home目录(根目录)也不一致

mv Alexey-Sviridkin-VXb42m0uM3s.jpg ~/mywebsite/static/

# 相对路径, mywebsite与github pages的项目名一致.
# 本地是无法显示图片的, 因为本地和Github Pages地址不一致, 相对路径也不一致.
![猫](/mywebsite/Alexey-Sviridkin-VXb42m0uM3s.jpg)

9. Hugo 可以开启支持markdown的HTML元素.

如使用的config.yml格式, 添加如下即可支持

markup:
    goldmark:
        renderer:
            unsafe: true

如使用的config.toml格式, 添加如下即可支持

[markup]
  defaultMarkdownHandler = "goldmark"
  [markup.goldmark]
    [markup.goldmark.renderer]
      unsafe = true

<a href="https://github.com" target="_blank">Github.com</a>

效果如下

Github.com

Markdown编辑软件 Li.003

Wed, 14 Jul 2021 23:28:27 +0800

本篇文章属于Hugo学习路线Li.028一部分

1. Windows Mac Linux全平台支持的工具.

MarkText, 免费开源, 支持Mac Windows Linux.

MarkText

Visual Studio Code, 开源, 免费, 全平台支持(Windows Mac Linux).

Visual Studio Code

Sublime Text 4, 收费, 全平台支持(Windows Mac Linux)

Sublime Text 4

插件sublime-markdown-extended

Atom, 开源, 免费, 全平台支持(Windows Mac Linux).

Atom

插件Markdown Preview

Vim 开源免费全平台支持(Windows Mac Linux).

Vim

vim插件tpope/vim-markdown

2. Mac iPhone iPad 端工具.

MarkText, 免费开源, 支持Mac Windows Linux.

MarkText

Ulysses 付费 (支持平台Mac iPhone iPad).

Ulysses

iA Writer 付费 (支持平台Mac iPhone iPad).

iA Writer

Bear 付费(支持平台Mac iPhone iPad).

Bear

Pretext 免费

Pretext

3. Android应用

坚果云

石墨文档

Markdown语法 Li.002

Wed, 14 Jul 2021 15:58:10 +0800

本篇文章属于Hugo学习路线Li.028一部分

Markdown是一种轻量级标记语言，创始人为约翰·格鲁伯。它允许人们使用易读易写的纯文本格式编写文档，然后转换成有效的XHTML文档。这种语言吸收了很多在电子邮件中已有的纯文本标记的特性。 Markdown文件类型结尾是.md或.markdown形式.

优点: 简单统一(写一次任何地方显示一致) 支持网站平台多(Github Gitlab Wordpresse 知乎简书等)

编辑软件推荐: Typora 和 MarkText

更多应用

1. 标题

# 标题1
## 标题2
### 标题3
#### 标题4
##### 标题5
###### 标题6

标题1

标题2

标题3

标题4

标题5

标题6

2. 图片与链接.

[知乎](https://zhihu.com)

![图片](https://images.unsplash.com/photo-1545065942-3a37886535d5?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=2250&q=80)

#目录路径,访问的当前网站根目录下的图片.
![猫](/Alexey-Sviridkin-VXb42m0uM3s.jpg)
![猫](../../../Alexey-Sviridkin-VXb42m0uM3s.jpg)

知乎

3. 段落

段落一
没有空行, 仍然是段落一

空一行就是段落二

段落一没有空行, 仍然是段落一

空一行就是段落二

4 列表. 有序列表与无序列表.

4.1 有序列表

1. 有序列表一
2. 有序列表一
3. 有序列表一

有序列表一
有序列表一
有序列表一

4.2 无序列表. -与*同义.

* 无序列表一
* 无序列表二
    * 无序列表一一
    * 无序列表一二
        * 无序列表一一一
- 无序列表一
- 无序列表二
    - 无序列表一一
    - 无序列表一二
        - 无序列表一一一

无序列表一
无序列表二
- 无序列表一一
- 无序列表一二
  - 无序列表一一一

无序列表一
无序列表二
- 无序列表一一
- 无序列表一二
  - 无序列表一一一

5. 代码块``` ```

"```"
6个`包围就是代码区域
"```"

public static void main(){
    System.out.println("Hello");
}

6. Markdown同样支持所有HTML标签

例如a img标签

<a href="https://github.com" target="_blank" >Github.com</a>
<img src="https://images.unsplash.com/photo-1545065942-3a37886535d5?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=2250&q=80">

Github.com

7. 表格

| 标题一 | 标题二 | 标题三 |
| ---   | ---   | ---   |
| 内容一 | 内容二 | 内容三 |

标题一	标题二	标题三
内容一	内容二	内容三

8. 引用.

>引用内容 线上服务

引用内容线上服务

9. 强调****

普通 **强调**

普通强调

10. 任务* -

- [ ] 任务一
- [x] 完成任务二
  - [x] 完成任务三
- [ ] 待完成任务四

任务一
完成任务二
- 完成任务三
待完成任务四

11.分隔线 —

分隔线

---

分隔线

12.字符转义\

\*
\\
\-

13. 删除线~~~~

~~删除线~~

~~删除线~~

14. 数学公式, 其它内容.

<abbr title="Graphics Interchange Format">GIF</abbr> is a bitmap image format.

H<sub>2</sub>O

X<sup>n</sup> + Y<sup>n</sup> = Z<sup>n</sup>

Press <kbd><kbd>CTRL</kbd>+<kbd>ALT</kbd>+<kbd>Delete</kbd></kbd> to end the session.

Most <mark>salamanders</mark> are nocturnal, and hunt for insects, worms, and other small creatures.

GIF is a bitmap image format.

H₂O

Xⁿ + Yⁿ = Zⁿ

Press CTRL+ALT+Delete to end the session.

Most salamanders are nocturnal, and hunt for insects, worms, and other small creatures.