Java on 杨刚的个人网站

1、AWT

Tue, 06 May 2025 00:00:00 +0000

Java 图形化界面
#

Java使用AWT和Swing相关的类可以完成图形化界面编程，其中AWT的全称是抽象窗口工具集(Abstract Window Toolkit),它是sun公司最早提供的GUI库，这个GUI库提供了一些基本功能，但这个GUI库的功能比较有限，所以后来sun公司又提供了Swing库。通过使用AWT和Swing提供的图形化界面组件库，java的图形化界面编程非常简单，程序只需要依次创建所需的图形组件，并以合适的方式将这些组件组织在一起，就可以开发出非常美观的用户界面。

1、SpringBoot

Wed, 12 Feb 2025 00:00:00 +0000

Spring Boot
#

概念
#

Spring Boot 基于 Spring 开发，Spirng Boot 本身并不提供 Spring 框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于 Spring 框架的应用程序。也就是说，它并不是用来替代 Spring 的解决方案，而是和 Spring 框架紧密结合用于提升 Spring 开发者体验的工具。Spring Boot 以约定大于配置的核心思想，默认帮我们进行了很多设置，多数 Spring Boot 应用只需要很少的 Spring 配置。同时它集成了大量常用的第三方库配置（例如 Redis、MongoDB、Jpa、RabbitMQ、Quartz 等等），Spring Boot 应用中这些第三方库几乎可以零配置的开箱即用。

1、Redis

Wed, 11 Dec 2024 00:00:00 +0000

数据库概述
#

数据库分为关系型数据库，非关系型数据库

1、Swagger

Thu, 05 Dec 2024 00:00:00 +0000

Swagger在线文档技术
#

现在来讲，最主流的开发模式：前后端分离
前端编写页面，以及完成后端接口的调用
后端：提供数据接口，以及需要提交接口所对应的接口文档

参照的示例
#

1、Mybatis

Tue, 05 Nov 2024 00:00:00 +0000

Mybatis
#

Mybatis是一个优秀的基于java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。
iBATIS一词来源于internet和abatis的组合，是一个基于Java的持久层框架。
iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO）
基于ORM（对象关系映射）思想的一个框架
MyBatis 是支持定制化SQL、存储过程以及高级映射的优秀的持久层框架。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以对配置和原生Map使用简单的 XML 或注解，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。
官网地址：https://blog.mybatis.org/

优点
#

简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件；易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现
灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求
解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性
提供映射标签，支持对象与数据库的orm字段关系映射
提供对象关系映射标签，支持对象关系组建维护
提供xml标签，支持编写动态sql

缺点
#

编写sql语句工作量大，尤其字段多，关联表多
sql语句依赖于数据库，导致数据库一致性差，不可以更换数据库
框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写，工作量大，而且不太容易适应快速数据库修改
二级缓存机制不佳

简单使用
#

1、导入mybatis依赖
#

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.11</version>
</dependency>

2、导入目标数据库的对应驱动
#

目前使用的是mysql5.7.28

1、JVM与GC

Tue, 24 Sep 2024 00:00:00 +0000

JVM的空间
#

JVM有一个称为垃圾回收器的低级线程，这个线程在后台不断地运行，自动寻找在Java程序中不再被使用的对象，并释放这些对象的内存。这种内存回收的过程被称为垃圾回收（Garbage Collection）

1、时间日期

Mon, 27 May 2024 00:00:00 +0000

java.lang.System
#

System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。

1、JavaWeb与Tomcat

Fri, 19 Jan 2024 00:00:00 +0000

JavaEE
#

Java EE（现在称为Jakarta EE）是Java平台的一个扩展，专注于开发和运行企业级应用程序。它提供了一组标准规范和API，用于构建可扩展、安全、可靠且高性能的分布式应用程序。Java EE涵盖了广泛的功能领域，包括Web应用程序开发、持久化、消息传递、事务管理、安全性等。

1、Maven

Fri, 19 Jan 2024 00:00:00 +0000

Maven
#

Maven 是一个项目管理工具，它包含了一个项目对象模型 (POM： Project Object Model)，一组标准集合，一个项目生命周期(Project Lifecycle)，一个依赖管理系统(Dependency Management System)，和用来运行定义在生命周期阶段中插件(plugin)目标的逻辑。

1、Spring

Fri, 19 Jan 2024 00:00:00 +0000

Spring概述
#

Spring框架是03年由Rod Johnson创建
该框架的主要作用：让我们的应用程序满足“高内聚，低耦合”，并始终遵循面向接口编程的思想，来做到松散耦合
Spring不是一个功能性框架，主要解决的是业务逻辑层和其他各层的耦合问题
Spring框架核心
- IOC（容器），把创建、销毁对象的过程交给Spring进行管理
- AOP（面向切面编程），可以在不修改源代码的情况下，进行功能的增强

Spring的特点
#

免费开源，功能不够可以自己去扩展
它使用IOC容器，管理项目中的所有的组件，以及维护组件之间的关系
它为企业应用开发，或者互联网应用开发提供了一套非常完整的解决方案
是一个轻量级的开源的JavaEE的框架

Spring的优点
#

方便程序解耦，简化开发（高内聚低耦合）
- 它的底层实现采用的是：工厂 + 反射 + 配置文件
它可以帮助程序员去创建组件的实例
它可以帮助程序员去管理组件之间的依赖关系
AOP编程的支持
- Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
声明式事务的支持
- 只需要通过配置就可以完成对事务的管理，而无需手动编程
方便程序的测试
- Spring对Junit4支持，可以通过注解方便的测试Spring程序
方便集成各种优秀框架
- Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持
降低JavaEE API的使用难度
- Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低

Spring体系结构
#

1、SpringMVC

Fri, 19 Jan 2024 00:00:00 +0000

SpringMVC
#

Spring Web MVC，Spring七大功能之一，就是这里springMVC框架，它主要是一种采用MVC设计模式的表现层框架

1、SpringSecurity

Fri, 19 Jan 2024 00:00:00 +0000

什么是SpringSecurity
#

Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。

1、ElasticSearch

Sat, 11 Nov 2023 00:00:00 +0000

全文检索
#

MySQL存储数据时，采用表格的方式（行和列）的方式来进行存储
Redis存储数据时，采用K-V结构的方式来进行存储
当数据量非常庞大时（T，P级），提升查询效率

需求
#

说：Redis简单，知道Key就可以，但如果其他人问你说我不知道Key，我只是知道大概的值，如何提升效率？

1、JavaFX概述

Sat, 11 Nov 2023 00:00:00 +0000

JavaFX
#

界面结构
#

1、java语言概述

Sat, 11 Nov 2023 00:00:00 +0000

java基础知识图解
#

1、JNA

Sat, 11 Nov 2023 00:00:00 +0000

JNI和JNA
#

Java原生自带的JNI，它允许Java代码和其他语言（尤其C/C++）写的代码进行交互，只要遵守调用约定即可。首先看下JNI调用C/C++的过程，注意写程序时自下而上，调用时自上而下。

1、JVM和Java体系结构

Sat, 11 Nov 2023 00:00:00 +0000

JVM
#

JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的

1、Nginx+Tomcat集群

Sat, 11 Nov 2023 00:00:00 +0000

Tomcat存在的问题
#

1、Tomcat：一种轻量级的WEB容器，它的适用场景中小型系统或者并发量不高的系统，它是apache平台与Sun公司一起合作开发出来的，专门支持Servlet的一种WEB容器

1、RabbitMQ

Sat, 11 Nov 2023 00:00:00 +0000

消息队列
#

MQ是消息队列服务器，产品：ActiveMQ，RabbitMQ，RocketMQ，Kafka……

1、Shiro

Sat, 11 Nov 2023 00:00:00 +0000

Shiro简介
#

公司项目中，常见的权限框架：shiro，spring security
Apache Shiro是一个功能强大且灵活的开源安全框架，可以清晰地处理身份验证，授权，企业会话管理和加密
Apache Shiro的首要目标是易于使用和理解。安全有时可能非常复杂，甚至是痛苦的，但并非必须如此。框架应尽可能掩盖复杂性，并提供简洁直观的API，以简化开发人员确保其应用程序安全的工作

Shiro能帮系统做什么
#

做用户的身份认证，判断用户是否系统用户（重点）
给系统用户授权，用来帮助系统实现不同的用户展示不同的功能（重点）
针对密码等敏感信息，进行加密处理（明文变成密文）（重点）
提供了Session管理，但是它的Session不是HttpSession，是它自己自带的
做授权信息的缓存管理，降低对数据库的授权访问
提供测试支持，因为它也是一个轻量级框架，它也可以直接针对代码进行使用Junit单元测试
提供Remeber me的功能，可以做用户无需再次登录即可访问某些页面

Shiro提供的10大功能
#

1、Stage

Sat, 11 Nov 2023 00:00:00 +0000

javafx.stage.Stage，在一个javafx桌面应用程序里显示一个窗口。在JavaFX Stage内部，你可以插入一个JavaFX Scence，来显示窗口里要的内容。

1、WebService

Sat, 11 Nov 2023 00:00:00 +0000

WebService简介
#

Web Service技术，能使得运行在不同机器上的不同应用无须借助附加的、专门的第三方软件或硬件，就可相互交换数据或集成。依据Web Service规范实施的应用之间，无论它们所使用的语言、平台或内部协议是什么，都可以相互交换数据。

1、代理模式

Sat, 11 Nov 2023 00:00:00 +0000

原理
#

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

1、单例模式

Sat, 11 Nov 2023 00:00:00 +0000

要解决的问题：
#

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。

1、基于springboot项目构建

Sat, 11 Nov 2023 00:00:00 +0000

准备工作
#

项目采用idea开发，所以不需要插件，使用spring-boot+javaFx，实现MVC结构，整体项目结构类似于spirngboot项目

1、枚举类

Sat, 11 Nov 2023 00:00:00 +0000

枚举，顾名思义：就是一个一个列举出来

当需要定义一组常量时，强烈建议使用枚举类

1、设计模式概述

Sat, 11 Nov 2023 00:00:00 +0000

设计模式是在大量的实践中总结和理论化之后优的代码结构、编程风格、以及解决问题的思考方式。

1、微服务

Sat, 11 Nov 2023 00:00:00 +0000

微服务简介
#

倡导者：Martin Fowler，文章网址：http://martinfowler.com/articles/microservices.html

2、settings.xml

Thu, 03 Jul 2025 00:00:00 +0000

settings.xml
#

Maven有一个settings.xml配置文件，它是用来设置 Maven 参数的配置文件，settings.xml 中包含类似本地仓储位置、修改远程仓储服务器、认证信息等配置。

2、Swing

Wed, 07 May 2025 00:00:00 +0000

Swing 概念
#

实际使用 Java 开发图形界面程序时，很少使用 AWT 组件，绝大部分时候都是用 Swing 组件开发的。

2、集合

Tue, 18 Feb 2025 00:00:00 +0000

继承树
#

Collection接口
#

2、Thymeleaf

Fri, 03 Jan 2025 00:00:00 +0000

JSP的缺陷
#

JSP就是一个Servlet ，生命周期：翻译，编译，加载，初始化，服务，销毁
Servlet一定要放置在Servlet容器中才可以运行，浏览器不能直接解析
JSP页面一般构成：HTML + CSS + JS + Java代码 + JSTL标记
由此的坏处：
- JSP必须要在Servlet容器解析成HTML，才可以返回到浏览器中（系统：不管是静态请求也好，还是动态请求，都压到Tomcat服务器，这就可能导致Tomcat解决动态请求的能力有所降低）
- JSP必须要在Servlet容器解析成HTML，这就意味着百度，谷歌，以及其他的搜索引擎无法去收录
JSP从2015年之前，就开始走向灭亡，取而代之的是，HTML + 模板引擎

模板引擎
#

使用符号或者自定义标记 + 网页中不变的东西 = 模板引擎
模板引擎的作用：将页面中动态的内容，使用标记或某些符号，进行静态的替换。从而做到：浏览器认为整个网页都是静态的内容（进而可以做到：浏览器缓存HTML，Nginx等服务器缓存HTML）从而提升系统的整合响应性能
常见的模板引擎**：Freemarker，thymeleaf，velocity**

Thymeleaf的特点
#

Thymeleaf 模板引擎具有以下特点：

2、对数据库的操作

Mon, 09 Dec 2024 00:00:00 +0000

添加、删除、修改
#

//GoodTypeDaoMapper接口
//1、增加
boolean addOne(GoodType goodType);
//2、删除
boolean removeById(int tid);
//3、修改
boolean updateNameById(String tname,int tid);

<!--GoodTypeDaoMapper.xml映射文件-->
<!--1、增加-->
<insert id="addOne">
    insert into goodtype (tid,tname,state,remarks) values (#{tid},#{tname},#{state},#{remarks})
</insert>
<!--2、删除-->
<delete id="addOne">
    delete from goodtype where tid=#{tid}
</delete>
<!--3、修改-->
<update id="updateNameById">
    update goodtype set tname=#{arg0} where tid=#{arg1}
</update>

添加数据并获取主键值
#

方式一
#

<insert id="add" 
        useGenneratedKeys="true" 
        keyColumn="tid" 
        keyProperty="tid">
    insert into goodtype (tname,state,remarks) values (#{tname},#{state},#{remarks})
</insert>

方式二
#

<insert id="add">
    <selectKey keyColumn="tid"
               keyProperty="tid" 
               resultType="int" 
               order="AFTER">
        select last_insert_id()
    </selectKey>
    insert into goodtype (tname,state,remarks) values (#{tname},#{state},#{remarks})
</insert>

查询
#

简单查询
#

//GoodTypeDaoMapper接口
List<GoodType> findAll();

<!--UserDao.xml:-->
<select id="findAll" resultType="entity.GoodType">
    select * from goodtype
</select>

多表查询
#

一对一
#

根据商品id查询出商品Goods信息，以及对应的商品类型GoodType信息

2、集群的实现，动静分离

Wed, 03 Apr 2024 00:00:00 +0000

Nginx的使用
#

Nginx启动
#

//在Nginx的目录下使用dos命令
start nginx.exe  #启动nginx
nginx -s reload  #nginx可以重新加载文件
nginx -t #查看配置文件是否有错
nginx -s stop #停止nginx

Nginx整合Tomcat，并实现动静分离（单个Tomcat）
#

修改nginx.conf文件
#

listen：表示当前的代理服务器监听的端口，默认的是监听80端口。注意，如果我们配置了多个server，这个listen要配置不一样，不然就不能确定转到哪里去了。
server_name：表示监听到之后需要转到哪里去，这时我们直接转到本地，这时是直接到nginx文件夹内。
location：表示匹配的路径，这时配置了/表示所有请求都被匹配到这里
root：里面配置了root这时表示当匹配这个请求的路径时，将会在这个文件夹内寻找相应的文件，这里对我们之后的静态文件伺服很有用。
index：当没有指定主页时，默认会选择这个指定的文件，它可以有多个，并按顺序来加载，如果第一个不存在，则找第二个，依此类推。

server {
    listen 80;
    #为虚拟服务器的识别路径。因此不同的域名会通过请求头中的HOST字段，匹配到特定的server块，转发到对应的应用服务器中去。
    server_name localhost:8080; 
    # proxy_pass:它表示代理路径，相当于转发，而不像之前说的root必须指定一个文件夹
    location / {
        root   html;
        index  index.html index.htm;
        proxy_pass http://localhost:8080;
    } 
    #静态文件交给nginx处理
    location ~ .*\.(js|css|htm|html|gif|jpg|jpeg|png|bmp|swf|ioc|rar|zip|txt|flv|mid|doc|ppt|pdf|xls|mp3|wma)$
    {
        root  G:/work/2018/prj04/src/main/webapp;
        expires 30d;
    }
    # 动态请求由反向代理分配去哪儿，见upstream{}
    location ~ .*$ {
        index index;
        proxy_pass http://localhost:8080;
    }
}

配置负载均衡（多个Tomcat）
#

1：启动多个tomcat

2、IOC

Fri, 19 Jan 2024 00:00:00 +0000

IOC与DI
#

Spring的IOC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）是Spring框架的核心概念，用于实现松耦合和可维护的应用程序。

2、java基础语法（上）：变量与运算符

Fri, 19 Jan 2024 00:00:00 +0000

关键字与保留字
#

关键字
#

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

2、前后端分离中使用

Fri, 19 Jan 2024 00:00:00 +0000

流程
#

2、详细使用

Fri, 19 Jan 2024 00:00:00 +0000

简单使用
#

1、创建Web项目
#

创建Java Enterprise项目，选择Maven管理依赖

2、CXF

Sat, 11 Nov 2023 00:00:00 +0000

整合SpringBoot+CXF
#

1、添加依赖
#

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>top.ygang</groupId>
    <artifactId>cxfdemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-parent</artifactId>
        <version>2.2.0.RELEASE</version>
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <cxf.version>3.2.1</cxf.version>
    </properties>

    <dependencies>
        <!-- webService-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web-services</artifactId>
        </dependency>

        <!-- CXF webservice -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-spring-boot-starter-jaxws</artifactId>
            <version>${cxf.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http</artifactId>
            <version>${cxf.version}</version>
        </dependency>
    </dependencies>
</project>

2、编写服务接口和服务实现类
#

@WebService(
        name = "testService",
        targetNamespace = "http://top.ygang.test/service",
        serviceName = "testService"
)
public interface TestService {

    @WebMethod(operationName = "testMethod")
    @WebResult(name = "message")
    String testMethod(@WebParam(name = "name") String name);
}

@Component
@WebService(
        name = "testService",
        targetNamespace = "http://top.ygang.test/service",
        serviceName = "testService"
)
public class TestServiceImpl implements TestService{

    @Override
    @WebMethod(operationName = "testMethod")
    @WebResult(name = "message")
    public String testMethod(@WebParam(name = "name")String name) {
        return "accept success : " + name;
    }
}

3、编写配置类
#

@Configuration
public class WSConfig {

    @Autowired
    private TestService testService;

    /**
     * Apache CXF 核心架构是以BUS为核心，整合其他组件。
     * Bus是CXF的主干, 为共享资源提供一个可配置的场所，作用类似于Spring的ApplicationContext，这些共享资源包括
     * WSDl管理器、绑定工厂等。通过对BUS进行扩展，可以方便地容纳自己的资源，或者替换现有的资源。默认Bus实现基于Spring架构，
     * 通过依赖注入，在运行时将组件串联起来。BusFactory负责Bus的创建。默认的BusFactory是SpringBusFactory，对应于默认
     * 的Bus实现。在构造过程中，SpringBusFactory会搜索META-INF/cxf（包含在 CXF 的jar中）下的所有bean配置文件。
     * 根据这些配置文件构建一个ApplicationContext。开发者也可以提供自己的配置文件来定制Bus。
     */
    @Bean(name = Bus.DEFAULT_BUS_ID)
    public SpringBus springBus() {
        return new SpringBus();
    }

    /**
     * 此方法作用是改变项目中服务名的前缀名，此处127.0.0.1或者localhost不能访问时，请使用ipconfig查看本机ip来访问
     * 此方法被注释后, 即不改变前缀名(默认是services)
     *
     * 如果启动时出现错误：not loaded because DispatcherServlet Registration found non dispatcher servlet dispatcherServlet
     * 可能是springboot与cfx版本不兼容。
     * 同时在spring boot2.0.6之后的版本与xcf集成，不需要在定义以下方法，直接在application.properties配置文件中添加：
     * cxf.path=/service（默认是services）
     */
//    @Bean
//    public ServletRegistrationBean dispatcherServlet() {
//        return new ServletRegistrationBean(new CXFServlet(), "/services/*");
//    }

    /**
     * 此方法的作用是发布服务
     */
    @Bean
    public Endpoint endpoint() {
        EndpointImpl endpoint = new EndpointImpl(springBus(), testService);
        endpoint.publish("/");
        return endpoint;
    }
}

4、启动类
#

@SpringBootApplication
public class Start {

    public static void main(String[] args) {
        SpringApplication.run(Start.class,args);
    }
}

5、访问浏览器查看wsdl
#

访问地址：http://127.0.0.1:8080/services/testService?wsdl

2、ELK安装

Sat, 11 Nov 2023 00:00:00 +0000

ELK
#

ELK是ElasiticSearch+LogStash+Kibana的三合一版本

2、Http协议

Sat, 11 Nov 2023 00:00:00 +0000

HTTP协议
#

超文本传输协议（hypertext transport protocol），服务端和客户端发送数据，需要遵守的协议，传递的数据又称为报文

2、Java操作RabbitMQ

Sat, 11 Nov 2023 00:00:00 +0000

准备工作
#

1、查看数据端口，默认5672
#

2、Object

Sat, 11 Nov 2023 00:00:00 +0000

java.lang.Object
#

Object类是所有Java类的根父类
如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
Object类中的功能(方法)具有通用性。
Object类只声明了一个空参的构造器

registerNatives()
#

native方法，让程序主动将本地方法链接到调用方，当Java程序需要调用本地方法时就可以直接调用，而不需要虚拟机再去定位并链接。

2、Platform、Task

Sat, 11 Nov 2023 00:00:00 +0000

javafx.application.Platform
#

作为JavaFx的工具类

2、Redis常用命令

Sat, 11 Nov 2023 00:00:00 +0000

通用命令
#

连接数据库
redis-cli	使用默认IP地址和端口连接Redis数据库（IP地址：127.0.0.1，端口号6379）
redis-cli -h 192.168.2.144 -p 6379	使用指定IP地址和端口连接Redis数据库
持久化
save	将数据同步保存到磁盘(存储在dump.rdb文件中)
bgsave	将数据异步保存到磁盘
lastsave	返回上次成功将数据保存到磁盘的Unix时戳
shundown	将数据同步保存到磁盘，然后关闭服务
远程服务控制
info	提供服务器的信息和统计
monitor	实时转储收到的请求
slaveof	改变复制策略设置
config	在运行时配置Redis服务器
对value操作的命令
exists(key)	确认一个key是否存在
del(key)	删除一个key
type(key)	返回值的类型
keys(pattern)	返回满足给定pattern的所有key
randomkey	随机返回key空间的一个
keyrename(oldname, newname)	重命名key
dbsize	返回当前数据库中key的数目
expire	设定一个key的活动时间（s）
ttl	获得一个key的活动时间
select(index)	按索引查询（切换到指定的数据库），默认索引为0
move(key, dbindex)	移动当前数据库中的key到dbindex数据库
flushdb	删除当前选择数据库中的所有key
flushall	删除所有数据库中的所有key

对String操作的命令
#

set(key, value)	给数据库中名称为key的string赋予值value
get(key)	返回数据库中名称为key的string的value
getset(key, value)	给名称为key的string赋予上一次的value
mget(key1, key2,…, key N)	返回库中多个string的value
setnx(key, value)	添加string，名称为key，值为value
setex(key, time, value)	向库中添加string，设定过期时间time
mset(key N, value N)	批量设置多个string的值
msetnx(key N, value N)	如果所有名称为key i的string都不存在
incr(key)	名称为key的string增1操作
incrby(key, integer)	名称为key的string增加integer
decr(key)	名称为key的string减1操作
decrby(key, integer)	名称为key的string减少integer
append(key, value)	名称为key的string的值附加value
substr(key, start, end)	返回名称为key的string的value的子串

对List操作的命令
#

rpush(key, value)	在名称为key的list尾添加一个值为value的元素
lpush(key, value)	在名称为key的list头添加一个值为value的元素
llen(key)	返回名称为key的list的长度
lrange(key, start, end)	返回名称为key的list中start至end之间的元素
ltrim(key, start, end)	截取名称为key的list
lindex(key, index)	返回名称为key的list中index位置的元素
lset(key, index, value)	给名称为key的list中index位置的元素赋值
lrem(key, count, value)	删除count个key的list中值为value的元素
lpop(key)	返回并删除名称为key的list中的首元素
rpop(key)	返回并删除名称为key的list中的尾元素
blpop(key1, key2,… key N, timeout)	lpop命令的block版本
brpop(key1, key2,… key N, timeout)	rpop的block版本
rpoplpush(srckey, dstkey)	返回并删除名称为srckey的list的尾元素，并将该元素添加到名称为dstkey的list的头部

对Set操作的命令
#

sadd(key, member)	向名称为key的set中添加元素member
srem(key, member)	删除名称为key的set中的元素member
spop(key)	随机返回并删除名称为key的set中一个元素
smove(srckey, dstkey, member)	移到集合元素
scard(key)	返回名称为key的set的基数
sismember(key, member)	member是否是名称为key的set的元素
sinter(key1, key2,…key N)	求交集
sinterstore(dstkey, (keys))	求交集并将交集保存到dstkey的集合
sunion(key1, (keys))	求并集
sunionstore(dstkey, (keys))	求并集并将并集保存到dstkey的集合
sdiff(key1, (keys))	求差集
sdiffstore(dstkey, (keys))	求差集并将差集保存到dstkey的集合
smembers(key)	返回名称为key的set的所有元素
srandmember(key)	随机返回名称为key的set的一个元素

对Hash操作的命令
#

hset(key, field, value)	向名称为key的hash中添加元素field
hget(key, field)	返回名称为key的hash中field对应的value
hmget(key, (fields))	返回名称为key的hash中field i对应的value
hmset(key, (fields))	向名称为key的hash中添加元素field
hincrby(key, field, integer)	将名称为key的hash中field的value增加integer
hexists(key, field)	名称为key的hash中是否存在键为field的域
hdel(key, field)	删除名称为key的hash中键为field的域
hlen(key)	返回名称为key的hash中元素个数
hkeys(key)	返回名称为key的hash中所有键
hvals(key)	返回名称为key的hash中所有键对应的value
hgetall(key)	返回名称为key的hash中所有的键（field）及其对应的value

2、Scene

Sat, 11 Nov 2023 00:00:00 +0000

搭建在窗口上的场景，各种组件、控件都必须放在场景上，Scene上必须有个根节点

2、SpringCloud

Sat, 11 Nov 2023 00:00:00 +0000

SpringCloud的概念
#

Spring Cloud框架是Spring框架中专门用来针对微服务开发的框架，它的原生是NetFlix公司开发的一套微服务框架，但是后来被Spring收购了
Spring Cloud框架产品中，提供了很多微服务服务组件，如: Eureka注册中心，Zuul网关组件，Configuration配置中心， Feign服务间通信， Hystrix服务降级，Bus消息总线等
SpringCloud已经闭源了，SpringCloud的版本均为英国伦敦的地铁站站名，最早的 Release 版本 Angel，第二个 Release 版本 Brixton（英国地名），然后是 Camden、 Dalston、Edgware、Finchley、Greenwich、Hoxton。

SpringCloud的组件
#

2、定时器

Sat, 11 Nov 2023 00:00:00 +0000

Java实现定时器的方式
#

1、Timer：这是Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行，一般使用比较少

2、类加载器子系统

Sat, 11 Nov 2023 00:00:00 +0000

类加载器子系统负责从文件系统或者网络中加载Class文件，class文件在开头有特定的文件标识

2、认证，加密，授权，缓存

Sat, 11 Nov 2023 00:00:00 +0000

认证
#

1、Controller登录方法
#

@RequestMapping("/login.do")
public String login(User user,ModelMap map){
    //获得一个主体对象
    Subject subject = SecurityUtils.getSubject();
    //将请求得到的用户名和密码放入一个令牌中
    UsernamePasswordToken token = new UsernamePasswordToken(user.getUaccount(),user.getUpsw());
    //调用主体对象的认证方法login，对令牌进行认证
    try{
        //触发Realm中doGetAuthenticationInfo()
        subject.login(token);
        Session session = subject.getSession();
        User nwoLogin = (User)subject.getPrincipal();
        session.setAttribute("nowLogin", nwoLogin);
    }catch(UnknownAccountException accountException){
        map.put("ex", "账号不存在");
        return "tologin.do";
    }catch(IncorrectCredentialsException passwordExeption){
        map.put("ex", "密码校验错误");
        return "tologin.do";
    }
    return "redirect:toMain.do";
}

2、Realm类中，doGetAuthenticationInfo方法进行登录认证
#

//身份认证方法，需要在用户登录系统时触发
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken arg0) throws AuthenticationException {
    //通过方法形参arg0，获取封装了用户账号密码的令牌
    UsernamePasswordToken token = (UsernamePasswordToken)arg0;
    //验证账号是否存在
    String uaccount = token.getUsername();
    User user = userService.selectByUaccount(uaccount);
    if(user == null){
        //如果用户名不存在，返回null
        //则shiro底层返回了一个异常(UnknownAccountException)
        return null;
    }
    //验证密码是否正确
    //第一个参数为，数据库查出的user对象，第二个参数为正确的密码，第三个参数为当前realm名
    //如果密码不正确，该构造器会抛出异常(IncorrectCredentialsException)
    return new SimpleAuthenticationInfo(user,user.getUpsw(),getName());
}

加密
#

1、ShiroConfig类中，设置加密
#

//设置加密类型(身份匹配器)，以及方式
@Bean
public HashedCredentialsMatcher credentialsMatcher() {
    HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
    // 说密码的加密方式为MD5 (不可逆的加密方式，只能加密，不能解密)
    credentialsMatcher.setHashAlgorithmName("MD5");
    // 针对MD5加密的信息，再加密1024次
    credentialsMatcher.setHashIterations(1024);
    return credentialsMatcher;
}
//配置shiro框架中，用来完成身份认证，授权的域对象
@Bean
public LoginAndAuthRealm loginAndAuthRealm() {
    LoginAndAuthRealm realm = new LoginAndAuthRealm();
    // 给Realm中配置身份对比规则
    realm.setCredentialsMatcher(credentialsMatcher());
    return realm;
}

2、修改Realm组件身份认证方法
#

//身份认证方法，需要在用户登录系统时触发
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken arg0) throws AuthenticationException {
    //通过方法形参arg0，获取封装了用户账号密码的令牌
    UsernamePasswordToken token = (UsernamePasswordToken)arg0;
    //验证账号是否存在
    String uaccount = token.getUsername();
    User user = userService.selectByUaccount(uaccount);
    if(user == null){
        //如果用户名不存在，返回null
        //则shiro底层返回了一个异常(UnknownAccountException)
        return null;
    }
    //验证密码是否正确
    //获取当前用户名，创建盐值对象
    ByteSource byteSource = ByteSource.Util.bytes(user.getUaccount());
    //第一个参数为，数据库查出的user对象，第二个参数为正确的密码，第三个参数为盐值对象，第四个参数为当前Realm名称
    //如果密码不正确，该构造器会抛出异常(IncorrectCredentialsException)
    return new SimpleAuthenticationInfo(user,user.getUpsw(),byteSource,getName());
}

3、控制层注册方法中，对密码进行MD5加密
#

String pwd = new SimpleHash("MD5", 密码,盐值‘一般为用户名’, 加密次数‘1024’).toString();

2、装饰者模式

Sat, 11 Nov 2023 00:00:00 +0000

原理
#

装饰者模式（DecoratorPattern）是指在不改变原对象的基础之上，将功能附加到对象上，提供了比继承更灵活性的替代方案（扩展原有对象的功能），装饰者模式属于结构型模式

3、OAuth2

Wed, 26 Feb 2025 00:00:00 +0000

OAuth2
#

OAuth 2.0 是目前最流行的授权标准（协议），用来授权第三方应用，获取用户数据。

3、Maven依赖

Thu, 23 Jan 2025 00:00:00 +0000

Parent
#

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.0.RELEASE</version>
</parent>

常用依赖
#

Web场景启动器
#

<!-- Web场景启动器 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

单元测试
#

<!-- 单元测试 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    <exclusions>
        <!-- JUnit Vintage是为了兼容3和4的一个engine，排除 -->
        <exclusion>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Mybatis场景启动器
#

<!-- Mybatis场景启动器 -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
</dependency>

Mbatis-Plus场景启动器
#

<!-- Mbatis-Plus场景启动器 -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.0</version>
</dependency>

MySQL
#

<!-- MySQL -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.15</version>
</dependency>

Oracle
#

<!-- Oracle -->
<dependency>
    <groupId>com.oracle</groupId>
    <artifactId>ojdbc6</artifactId>
    <version>11.2.0.3</version>
</dependency>

Druid场景启动器
#

<!-- Druid连接池场景启动器 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.6</version>
</dependency>

Lombok
#

<!-- Lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.22</version>
</dependency>

Redis场景启动器
#

<!-- Redis场景启动器 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Thymeleaf场景启动器
#

<!-- Thymeleaf场景启动器 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

JSP解析器
#

<!-- jsp依赖 -->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>

Fileupload文件上传组件
#

<!-- Fileupload文件上传组件 -->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
</dependency>

fastjson
#

<!-- fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.7</version>
</dependency>

pagehelper分页插件
#

<!-- pagehelper分页插件 -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.3.0</version>
</dependency>

AOP
#

<!-- AOP -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
</dependency>

Shiro
#

<!-- Shiro -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.4.0</version>
</dependency>
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-ehcache</artifactId>
    <version>1.3.2</version>
</dependency>
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-all</artifactId>
    <version>1.2.2</version>
</dependency>
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.2.2</version>
</dependency>
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-web</artifactId>
    <version>1.2.2</version>
</dependency>

POI
#

<!-- POI -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>4.1.2</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>4.1.2</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml-schemas</artifactId>
    <version>4.1.2</version>
</dependency>

Hutool
#

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.7.8</version>
</dependency>

SpringBoot打包插件
#

spring-boot-maven-plugin是Spring Boot提供的maven打包插件。可以将项目直接打包为可运行的jar包或war包。

3、Jedis与RedisTemplate

Fri, 13 Dec 2024 00:00:00 +0000

Jedis
#

使用步骤（Maven下使用）
#

1、pom.xml文件中导入依赖
#

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.3.0</version>
</dependency>

2、获取Redis对象，连接Redis
#

//无参构造为默认ip：127.0.0.1，端口号：6379
Jedis jedis = new Jedis("127.0.0.1",6379);

对于String类型的操作
#

Jedis jedis = new Jedis();
//清空所有数据库
jedis.flushAll();
for (int i = 0; i < 10; i++) {
    //insert
    jedis.set("key" + i,"value" + i);
}
//delete
jedis.del("key2");
//update
jedis.set("key1","vvvvv");
//findById
String s = jedis.get("key1");
System.out.println(s);
//findAll
Set<String> keys = jedis.keys("*");
Iterator<String> iterator = keys.iterator();
while (iterator.hasNext()){
    String key = iterator.next();
    String value = jedis.get(key);
    System.out.println("key:" + key + "value:" + value);
}

对于Set类型的操作
#

Jedis jedis = new Jedis();
jedis.flushAll();
//insert
jedis.sadd("person","lucy1");
jedis.sadd("person","lucy2");
jedis.sadd("person","lucy3");
jedis.sadd("person","lucy4");
jedis.sadd("person","lucy5");
//查询key的数据量
System.out.println(jedis.scard("person"));
//delete
jedis.srem("person","lucy1");
//findAll
Set<String> person = jedis.smembers("person");
System.out.println(person);

对于Zset类型的操作
#

Jedis jedis = new Jedis();
jedis.flushAll();
//insert,可以根据第二个参数值，进行排序
jedis.zadd("person",18,"lucy18");
jedis.zadd("person",9,"lucy9");
jedis.zadd("person",26,"lucy26");
jedis.zadd("person",4,"lucy4");
//delete
jedis.zrem("person","lucy9");
//查看key的数据量
System.out.println(jedis.zcard("person"));
//findAll
Set<String> person = jedis.zrange("person", 0, -1);
System.out.println(person);

对于List类型的操作
#

Jedis jedis = new Jedis();
jedis.flushAll();
for (int i = 0; i < 10; i++) {
    //在后面添加
    jedis.rpush("key","value" + i);
}
for (int i = 11; i < 20; i++) {
    //在前面添加
    jedis.lpush("key","value" + i);
}
//findById
System.out.println(jedis.lindex("key", 3));
//delete
jedis.lrem("key",1,"value1");
//update
jedis.lset("key",3,"vvvvv");
//findAll
List<String> key = jedis.lrange("key", 0, -1);
System.out.println(key);
//统计该key对应的value数量
System.out.println(jedis.llen("key"));

对于Hash类型的操作
#

Jedis jedis = new Jedis();
jedis.flushAll();
//insert
jedis.hset("person","name","lucy");
jedis.hset("person","sex","nv");
jedis.hset("person","age","18");
//update
jedis.hset("person","age","25");
//根据id获取值
System.out.println(jedis.hget("person", "age"));
//delete
jedis.hdel("person","sex");
//findAll
Map<String, String> map = jedis.hgetAll("person");
System.out.println(map);

spring-boot-starter-data-redis
#

使用步骤
#

1、导入依赖

3、配置ssl

Wed, 03 Apr 2024 00:00:00 +0000

1、域名服务商控制台对ssl进行域名解析

2、下载ssl证书，一共两个文件xxx.key、xxx.pem，上传到服务器

3、AOP

Fri, 19 Jan 2024 00:00:00 +0000

AOP
#

AOP的作用
#

AOP的最大作用：采用代码模式，将核心业务，与非核心业务进行分离关注

3、IO与NIO

Fri, 19 Jan 2024 00:00:00 +0000

File类
#

File类的一个对象，代表一个文件或一个文件目录(Directory)

3、Java基础语法（下）：程序流程控制

Fri, 19 Jan 2024 00:00:00 +0000

程序流程控制
#

3、Servlet

Fri, 19 Jan 2024 00:00:00 +0000

Servlet
#

Servlet(Server Applet)是Java Servlet的简称，称为小服务程序或服务连接器，用Java编写的服务器端程序，具有独立于平台和协议的特性，主要功能在于交互式地浏览和生成数据，生成动态Web内容，它是由Sun公司（现在是Oracle公司）开发的，作为Java Servlet API的一部分，包含在Java EE（Enterprise Edition）规范中

3、Session

Fri, 19 Jan 2024 00:00:00 +0000

生命周期
#

注意：这个Session不是Tomcat的那个，而是Shrio提供的一个Session

3、SpringMVC的注解

Fri, 19 Jan 2024 00:00:00 +0000

使用前提
#

如果需要使用MVC相关注解，需要在Spring核心配置文件applicationContext.xml中开启注解驱动

3、不同IDE逆向生成

Wed, 20 Dec 2023 00:00:00 +0000

逆向生成也就是使用插件，根据数据库表、字段、类型自动生成对应的Mybatis的Dao、Mapper、Entity

3、Axis2

Sat, 11 Nov 2023 00:00:00 +0000

整合SpringBoot+Axis2
#

1、添加依赖
#

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>top.ygang</groupId>
    <artifactId>axisdemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-parent</artifactId>
        <version>2.2.0.RELEASE</version>
    </parent>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <axis2.version>1.7.8</axis2.version>
    </properties>

    <dependencies>
        <!--   spring-boot-web    -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--   axis2     -->
        <dependency>
            <groupId>org.apache.axis2</groupId>
            <artifactId>axis2-spring</artifactId>
            <version>${axis2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.axis2</groupId>
            <artifactId>axis2-transport-http</artifactId>
            <version>${axis2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.axis2</groupId>
            <artifactId>axis2-transport-local</artifactId>
            <version>${axis2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.axis2</groupId>
            <artifactId>axis2-xmlbeans</artifactId>
            <version>${axis2.version}</version>
        </dependency>
    </dependencies>

</project>

2、在resources下创建目录以及文件
#

ServicePath/services/testService/META-INF/services.xml，其中只有目录testService的目录可变，其余目录都是固定

3、ES的使用

Sat, 11 Nov 2023 00:00:00 +0000

在ES7.0之后，types_name只可以写_doc

方式一：RestFul访问
#

在浏览器或PostMan中进行访问，注意选择请求的methods

3、Group

Sat, 11 Nov 2023 00:00:00 +0000

布局组件

Group group = new Group();
Button btn1 = new Button("btn1");
Button btn2 = new Button("btn2");
Button btn3 = new Button("btn3");
//添加组件
group.getChildren().addAll(btn1,btn2,btn3);
//移除指定组件
group.getChildren().remove(btn1);
Scene scene = new Scene(group);
primaryStage.setScene(scene);

//设置透明度（会影响子组件）
group.setOpacity(0.5);
//检测在指定位置上是否有子组件（只能检测到子组件的左上角点）
group.contains(0,0);

3、POI

Sat, 11 Nov 2023 00:00:00 +0000

用于在java程序中，解析读取excel文档

依赖
#

<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>3.14</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>3.14</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml-schemas</artifactId>
    <version>3.14</version>
</dependency>

工具类
#

public class POIUtil {
	//读取数据
    public static List<List<String>> read(String excelPath,int sheetNum){
        //根据文件后缀，创建不同的电子表格对象
        Workbook workbook = null;
        File file = new File(excelPath);
        InputStream input;
        try {
            input = new FileInputStream(file);
            if(excelPath.endsWith("xlsx")){
                //创建 Excel 2007 电子表格对象
                workbook = new XSSFWorkbook(input);
            }else{
                //创建 Excel 2003 工作簿对象
                workbook = new HSSFWorkbook(input);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return parse(workbook,sheetNum);
    }
    private static List<List<String>> parse(Workbook workbook,int sheetNum){
        //获取当前的工作簿
        Sheet sheet = workbook.getSheetAt(sheetNum);
        List<List<String>> excelList = new ArrayList<>();
        //遍历表格所有行
        for(int i = 0;i <= sheet.getLastRowNum();i++){
            //获取行对象
            Row row = sheet.getRow(i);
            //如果当前行为空，则开始下一行循环
            if(row == null){
                continue;
            }
            List<String> rowList = new ArrayList<>();
            //遍历行中的所有列
            for(int j = 0;j < row.getLastCellNum();j++){
                //获取列对象
                Cell cell = row.getCell(j);
                String cellStr = "";
                //判断当前列数据类型
                if(cell == null){
                    cellStr = "";
                }else if(cell.getCellType() == Cell.CELL_TYPE_BOOLEAN){
                    //布尔类型
                    cellStr = String.valueOf(cell.getBooleanCellValue());
                }else if(cell.getCellType() == Cell.CELL_TYPE_NUMERIC){
                    //数值类型
                    cellStr = (int)cell.getNumericCellValue() + "";
                }else if(cell.getCellType() == Cell.CELL_TYPE_FORMULA){
                    //公式类型
                    cellStr = cell.getCellFormula();
                }else{
                    //其余按字符串处理
                    cellStr = cell.getStringCellValue();
                }
                rowList.add(cellStr);
            }
            excelList.add(rowList);
        }
        return excelList;
    }
    //写入到excel
    public static String write(String[] title, String sheetName, List<List<String>> data,String excelPath){
        //创建Excel 2007 电子表格对象
        Workbook wb = new XSSFWorkbook();
        //设置sheet名称，并创建新的sheet对象
        Sheet sheet = wb.createSheet(sheetName);
        //获取表头行
        Row titleRow = sheet.createRow(0);
        //创建单元格，设置style居中，字体，单元格大小等
        CellStyle style = wb.createCellStyle();
        Cell cell = null;
        //把已经写好的标题行写入excel文件中
        for (int i = 0; i < title.length; i++) {
            cell = titleRow.createCell(i);
            cell.setCellValue(title[i]);
            cell.setCellStyle(style);
        }
        //将数据写入excel
        Row row = null;
        for (int i = 0;i < data.size();i++){
            row = sheet.createRow(i + 1);
            List<String> dataList = data.get(i);
            for (int j = 0;j < dataList.size();j++){
                row.createCell(j).setCellValue(dataList.get(j));
            }
        }
        //设置单元格宽度自适应，在此基础上把宽度调至1.5倍
        for (int i = 0; i < title.length; i++) {
            sheet.autoSizeColumn(i, true);
            //注意单个单元格的最大列宽是255个字符
            //sheet.setColumnWidth(i, sheet.getColumnWidth(i) * 15 / 10);
        }

        //创建上传文件目录
        File folder = new File(excelPath);

        //如果文件夹不存在创建对应的文件夹
        if (!folder.exists()) {
            folder.mkdirs();
        }
        //设置文件名
        Date date = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddhhmmss");
        String format = dateFormat.format(date);
        String fileName = format + sheetName + ".xlsx";
        String savePath = folder + File.separator + fileName;
        // System.out.println(savePath);
        try {
            OutputStream fileOut = new FileOutputStream(savePath);
            wb.write(fileOut);
            fileOut.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //返回文件保存全路径
        return savePath;
    }  
}

3、pom.xml

Sat, 11 Nov 2023 00:00:00 +0000

POM
#

POM（项目对象模型）是 Maven 最基本，也是非常重要的一个概念。通常情况下，我们可以看到 POM 的表现形式是pom.xml，在这个 XML 文件中定义着关于我们工程的方方面面，当我们想要通过 Maven 命令来进行操作的时候，例如：编译，打包等等，Maven 都会从pom.xml文件中来读取工程相关的信息。

3、Screen

Sat, 11 Nov 2023 00:00:00 +0000

主要用来获取屏幕信息

//获取主屏幕
Screen screen = Screen.getPrimary();
//获取用户的所有屏幕
ObservableList<Screen> screens = Screen.getScreens();

//获取当前屏幕dpi像素
screen.getDpi();
//获取用户可视屏幕的宽高
screen.getVisualBounds();
//获取全部屏幕宽高
screen.getBounds();

3、SpringBoot整合RabbitMQ

Sat, 11 Nov 2023 00:00:00 +0000

准备工作
#

1、添加依赖
#

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

2、修改配置文件
#

application.yml

3、包装类

Sat, 11 Nov 2023 00:00:00 +0000

包装类（封装类）
#

Java是一个面向对象的编程语言，但是Java中的八种基本数据类型却是不面向对象的，为了使用方便和解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八种基本数据类型对应的类统称为包装类(Wrapper Class)，包装类均位于java.lang包。

3、服务注册中心

Sat, 11 Nov 2023 00:00:00 +0000

注册中心以及服务注册
#

注册中心：是一个专用于完成微服务的注册，以及服务发现的东西
它采用的模式：发布/订阅模式
产品：Eureka（国外的），Nacos（国内阿里巴巴），ZooKeeper（动物园管理员）
这种产品非常多，具体使用情况具公司的情况具体使用

常用服务注册中心对比
#

	Nacos	Eureka	Consul	CoreDns	Zookeeper
一致性协议	CP + AP	AP	CP	/	CP
健康检查	TCP/HTTP/MySQL/client Beat	Client Beat	TCP/HTTP/gRPC/Cmd	/	Client Beat
负载均衡	权重/DSL/metaData/CMDB	Ribbon	Fabio	RR	/
雪崩保护	支持	支持	不支持	不支持	不支持
自动注销示例	支持	支持	不支持	不支持	支持
访问协议	HTTP/DNS/UDP	HTTP	HTTP/DNS	NNS	TCP
监听支持	支持	支持	支持	不支持	支持
多数据中心	支持	支持	支持	不支持	不支持
跨注册中心	支持	不支持	支持	不支持	不支持
Spring Cloud集成	支持	支持	支持	不支持	不支持
Dubbo集成	支持	不支持	不支持	不支持	支持
k8s集成	支持	不支持	不支持	支持	支持

Eureka
#

Eureka是SpringCloud体系中，专门用来完成服务的注册和发现的组件

4、JWT与SpringSession

Mon, 24 Feb 2025 00:00:00 +0000

SpringSession
#

SpringSession可以解决在微服务高可用或多个微服务中，JSESSIONID不同的问题

4、数据库连接池

Mon, 09 Dec 2024 00:00:00 +0000

数据库连接池
#

在原生的JDBC中，我们通常是使用对应的数据库驱动例如com.mysql.jdbc.Driver，获取一个java.sql.Connection对象进行操作（创建连接、执行SQL、关闭连接），所有的压力都在这一个Connection上。

4、JSP

Fri, 19 Jan 2024 00:00:00 +0000

JSP
#

JSP（全称JavaServer Pages）是由Sun Microsystems公司主导创建的一种动态网页技术标准。JSP部署于网络服务器上，可以响应客户端发送的请求，并根据请求内容动态地生成HTML、XML或其他格式文档的Web网页，然后返回给请求者。

4、plugins

Fri, 19 Jan 2024 00:00:00 +0000

Maven 的生命周期是抽象的，这意味着生命周期以及生命周期中每个phase（阶段）本身不做任何实际的工作，实际的任务都是依靠插件来完成。每个阶段都可以绑定一个或多个插件目标，Maven 为大多数构建步骤编写并绑定了默认插件。当用户有特殊需要的时候，可以自己配置插件来定制构建行为，甚至可以使用自己编写的 Maven 插件。

4、String

Fri, 19 Jan 2024 00:00:00 +0000

java.lang.String
#

概述
#

String：字符串，使用一对""引起来表示。

4、多线程

Fri, 19 Jan 2024 00:00:00 +0000

程序、进程、线程的区别
#

程序(program)
- 概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。
进程(process)
- 概念：程序的一次执行过程，或是正在运行的一个程序。
- 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
线程(thread)
- 概念：进程可进一步细化为线程，是一个程序内部的一条单一的执行路径（顺序控制流），可以共享所属进程的数据。
- 说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。

多线程程序的优点
#

提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

4、持久化、事务

Thu, 04 Jan 2024 00:00:00 +0000

持久化
#

优势Redis是基于缓存的存储，所以如果服务器宕机，会导致数据丢失，所以如果需要保存在磁盘上，需要使用持久化方案，Redis提供两种的持久化方案，RDB和AOF，默认情况下，开启了RDB方案，关闭AOF方案

4、配置类

Thu, 04 Jan 2024 00:00:00 +0000

声明配置类
#

SpringBoot的配置类的使用方法基本与SpringMVC中相同

4、数组

Thu, 04 Jan 2024 00:00:00 +0000

数组的概述
#

4、API

Sat, 11 Nov 2023 00:00:00 +0000

初始化接口
#

实现Initializable接口，重写initialize方法，可以在视图加载时调用

4、Button

Sat, 11 Nov 2023 00:00:00 +0000

按钮

Button btn = new Button("btn");
//鼠标点击事件
btn.setOnMouseClicked(new EventHandler<MouseEvent>() {
    @Override
    public void handle(MouseEvent event) {
        System.out.println("click");
    }
});
//鼠标双击以及鼠标按钮
btn.addEventHandler(MouseEvent.MOUSE_CLICKED, new EventHandler<MouseEvent>() {
    @Override
    public void handle(MouseEvent event) {
        if (event.getClickCount() == 2){
            System.out.println("click double");
            MouseButton mouseButton = event.getButton();
            // 获取鼠标按钮
            String name = mouseButton.name();
            System.out.println(name);
        }
    }
});

4、ES的查询

Sat, 11 Nov 2023 00:00:00 +0000

term查询
#

term query: 会去倒排索引中寻找确切的term，它并不知道分词器的存在。这种查询适合keyword 、numeric、date
term：查询某个字段为该关键词的文档（它是相等关系而不是包含关系）
term是代表完全匹配，即不进行分词器分析，必须全值匹配。查询不会对查询的字段进行分词查询，会采用精确匹配
可以用它处理数字（numbers）、布尔值（Booleans）、日期（dates）以及文本（text）

语法
#

如果字段类型为text，那么在插入的时候就会被分词，如果使用term查询的话，那么无法命中

4、Lombok

Sat, 11 Nov 2023 00:00:00 +0000

Lombok
#

Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java. Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more. Lombok简单理解就是一个Java类库，通过注解的形式帮助开发减少一些结构化代码的开发工作，提高开发效率，比如通过@Data注解，class在编译的时候会自动生成get，set，equals，hash，toString等方法，避免写大量的代码，减少了代码量，也使代码看起来更加简洁。尤其是一些对象属性需要改动的时候，每次改动都需要重新生成get，set，equals，hash，toString等方法，而使用注解则可以避免此问题。

4、Spring完全注解开发

Sat, 11 Nov 2023 00:00:00 +0000

Spring完全注解开发
#

完全注解开发是指在Spring应用中完全依赖注解进行配置和开发，而不使用XML配置文件。以下是完全注解开发的一些优点和缺点：

4、SSM整合

Sat, 11 Nov 2023 00:00:00 +0000

SSM整合
#

SSM整合即Spring + Spring MVC + Mybatis

4、WebFlux中使用

Sat, 11 Nov 2023 00:00:00 +0000

分布式开发时，微服务会有很多，但是网关是请求的第一入口，所以一般会把客户端请求的权限验证统一放在网关进行认证与鉴权。SpringCloud Gateway 作为 Spring Cloud 生态系统中的网关，目标是替代 Zuul，为了提升网关的性能，SpringCloud Gateway是基于WebFlux框架实现的，而WebFlux框架底层则使用了高性能的Reactor模式通信框架Netty。

4、微服务互相调用

Sat, 11 Nov 2023 00:00:00 +0000

微服务调用
#

在微服务架构中，最常见的场景就是微服务之间的相互调用。比如，用户微服务调用订单微服务发起一个下单的请求，在进行保存订单之前，需要调用商品微服务查询商品的信息。我们把调用方称为服务消费者，把请求的接收者称为服务提供者

5、常用插件

Mon, 10 Feb 2025 00:00:00 +0000

maven-jar-plugin
#

默认maven打包的结果没有指定mainClass，所以使用java -jar命令会显示xxx.jar中没有主清单属性，使用此插件可以指定mainClass

5、跨域处理CORS

Mon, 09 Dec 2024 00:00:00 +0000

要解决的问题
#

5、日志系统

Fri, 29 Nov 2024 00:00:00 +0000

日志系统
#

日志文件
#

日志文件是用于记录系统操作事件的文件集合，可分为事件日志和消息日志。具有处理历史数据、诊断问题的追踪以及理解系统的活动等重要作用。
在计算机中，日志文件是记录在操作系统或其他软件运行中发生的事件或在通信软件的不同用户之间的消息的文件。记录是保持日志的行为。在最简单的情况下，消息被写入单个日志文件。
许多操作系统，软件框架和程序包括日志系统。广泛使用的日志记录标准是在因特网工程任务组（IETF）RFC5424中定义的syslog。 syslog标准使专用的标准化子系统能够生成，过滤，记录和分析日志消息

调试日志
#

软件开发中，我们经常需要去调试程序，做一些信息，状态的输出便于我们查询程序的运行状况。为了让我们能够更加灵活和方便的控制这些调试的信息，所以我们需要专业的日志技术。java中寻找bug会需要重现。调试也就是debug 可以在程序运行中暂停程序运行，可以查看程序在运行中的情况。日志主要是为了更方便的去重现问题。

5、Async

Fri, 19 Jan 2024 00:00:00 +0000

Spring封装了一个异步方法的实现，使得方法可以在单独的线程中异步执行，提高系统的并发能力和响应性能。

5、面向对象编程（上）

Fri, 19 Jan 2024 00:00:00 +0000

面向对象内容的三条主线
#

1.Java类及类的成员：属性、方法、构造器；代码块、内部类

5、网络编程

Fri, 19 Jan 2024 00:00:00 +0000

实现网络通信需要解决的两个问题
#

如何准确地定位网络上一台或多台主机；并且定位主机上的特定的应用？
找到主机后如何可靠高效地进行数据传输？

网络通信的两个要素
#

IP和端口号，解决上面问题1
网络通信协议，例如TCP/IP参考模型（应用层、传输层、网络层、物理+数据链路层），解决上面问题2

通信要素一：IP和端口号
#

IP
#

IP：唯一的标识 Internet 上的计算机（通信实体）
在Java中使用InetAddress类代表IP
IP分类：IPv4和 IPv6
域名: www.baidu.com，www.mi.com，www.sina.com，www.jd.com
- 域名解析：域名容易记忆，当在连接网络时输入一个主机的域名后，域名服务器（DNS）负责将域名转化成IP地址，这样才能和主机建立连接。
本地回路地址：127.0.0.1对应着localhost

InetAddress类
#

此类的一个对象就代表着一个具体的IP地址，没有公共的构造方法，需要使用以下静态方法实例化
- public static InetAddress getLocalHost()
- public static InetAddress getByNames(String host)
常用方法
- public String getHostAddress()：返回IP地址字符串
- public String getHostName()：返回此IP地址主机名
- public boolean isReachable(int timeout)：测试是否可以连通此地址

//1.获取本机地址ip对象
InetAddress ip1 = InetAddress.getLocalHost();
System.out.println(ip1.getHostName());//获取主机名字
System.out.println(ip1.getHostAddress());//获取ip地址
//2.获取域名ip对象
InetAddress ip2 = InetAddress.getByName("www.baidu.com");
System.out.println(ip2.getHostName());//获取域名
System.out.println(ip2.getHostAddress());//获取域名的ip地址
//3.获取公网对象
InetAddress ip3 = InetAddress.getByName("112.80.248.76");
System.out.println(ip3.getHostName());//获取公网名字
System.out.println(ip3.getHostAddress());//获取公网ip地址
//判断网络是否能连接通信 ping 5s之前测试是否能通过
System.out.println(ip3.isReachable(5000));//通过会返回true

端口号
#

正在计算机上运行的进程。

5、会话技术

Thu, 04 Jan 2024 00:00:00 +0000

会话技术
#

HTTP是一种无状态协议，每当用户发出请求时，服务器就会做出响应，客户端与服务器之间的联系是离散的、非连续的，服务器无法知道连接是否来自于同一个客户端。会话技术就是为了解决这个问题，通俗来讲，为了证明你就是你

5、Analysis分词器

Sat, 11 Nov 2023 00:00:00 +0000

中文分词器
#

分词，一定是建立在创建“倒排索引”之前。ES将字符串划分为2种类型：Keyword和Text

5、MybatisCache&Redis

Sat, 11 Nov 2023 00:00:00 +0000

Mybatis二级缓存存在的问题
#

1、Mybatis自带的二级缓存是对当前容器而言的，存储在一个map集合对象中，如果容器重启，那么会导致缓存丢失

5、分布式存储Minio

Sat, 11 Nov 2023 00:00:00 +0000

分布式存储
#

1、分布式存储是一种数据存储技术，通过网络使用企业中的每台机器上的磁盘空间，并将这些分散的存储资源构成一个虚拟的存储设备，数据分散的存储在企业的各个角落。

5、服务熔断降级

Sat, 11 Nov 2023 00:00:00 +0000

服务雪崩
#

在微服务架构中通常会有多个服务层调用，基础服务的故障可能会导致级联故障，进而造成整个系统不可用的情况，这种现象被称为服务雪崩效应

5、拦截器

Sat, 11 Nov 2023 00:00:00 +0000

SpringMVC的拦截器
#

SpringMVC的拦截器，类似于Servlet中的过滤器Filter，都是用来对处理器进行预处理和后处理。开发者可以通过拦截器自定义一些功能。区别在于过滤器可以过滤所有请求（动态请求，静态请求），但是拦截器只能拦截动态请求（用于控制层）

5、正则表达式

Sat, 11 Nov 2023 00:00:00 +0000

正则表达式
#

正则表达式定义了字符串的模式。
正则表达式可以用来搜索、编辑或处理文本。
正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。

语法
#

6、HttpClient

Thu, 16 Jan 2025 00:00:00 +0000

HttpClient
#

HttpClient是客户端的http通信实现库，这个类库的作用是接收和发送http报文，使用这个类库，它相比传统的 HttpURLConnection，增加了易用性和灵活性，我们对于http的操作会变得简单一些。

6、分布式事务

Wed, 03 Apr 2024 00:00:00 +0000

分布式事务
#

分布式事务概念
#

本地事务：单体应用对应的单个数据库的事务
- 事务的目的：保证整个业务流程，要么统一成功，要么统一失败
- 通过单体应用中的事务管理器（TransactionManagement），可以保证事务的完整性
分布式事务
- 现在，我们用的是微服务。微服务的特点：一个微服务对应一个数据库
- 分布式程序，或微服务程序是相互独立的模块，都是远程调用，无法继续使用本地事务控制

6、WebSokect

Fri, 19 Jan 2024 00:00:00 +0000

WebSocket
#

WebSocket是HTML5提供的一种新的网络通信协议。它实现了服务端与客户端的全双工通信，建立在传输层TCP协议之上，即浏览器与服务端需要先建立TCP协议，再发送WebSocket连接建立请求。

6、泛型

Fri, 19 Jan 2024 00:00:00 +0000

泛型的概念
#

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用（例如，继承或实现这个接口，用这个类型声明变量、创建对象时确定（即传入实际的类型参数，也称为类型实参）。

6、面向对象编程（中）

Fri, 19 Jan 2024 00:00:00 +0000

关键字：static（静态）
#

作用范围
#

可以用来修饰的结构：主要用来修饰类的内部结构

6、Filter

Sat, 11 Nov 2023 00:00:00 +0000

Filter
#

过滤器，是JavaWeb三大组件之一，是一个驻留在服务端的Web组件，可以截取用户端和资源之间的请求和响应信息，并对信息进行过滤
过滤器可以把对web资源的请求和响应拦截下来，做一些处理后再交给下一个过滤器或客户端。从而实现一些特殊的功能。
过滤器一般完成一些通用操作，比如：自动登录、权限控制、统一编码格式设置、敏感字符过滤等。

工作流程
#

6、Schedule

Sat, 11 Nov 2023 00:00:00 +0000

在Spring框架中，提供了一些用于调度任务的注解，用于实现定时任务的执行。

6、SpringCache&Redis

Sat, 11 Nov 2023 00:00:00 +0000

关于Spring Cache
#

Spring Cache是作用在方法上的，其核心思想是这样的：当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值对存放在缓存中，等到下次利用同样的参数来调用该方法时将不再执行该方法，而是直接从缓存中获取结果进行返回。所以在使用Spring Cache的时候我们要保证我们缓存的方法对于相同的方法参数要有相同的返回结果。

6、UUID

Sat, 11 Nov 2023 00:00:00 +0000

java.util.UUID
#

什么是UUID
#

UUID是国际标准化组织（ISO）提出的一个概念。这个数值可以通过一定的算法计算出来。为了提高效率，常用的UUID可缩短至16位。UUID用来识别属性类型，在所有空间和时间上被视为唯一的标识。一般来说，可以保证这个值是真正唯一的任何地方产生的任意一个UUID都不会有相同的值。UUID是基于当前时间、计数器（counter）和硬件标识（通常为无线网卡的MAC地址）等数据计算生成的。

6、服务网关

Sat, 11 Nov 2023 00:00:00 +0000

微服务网关
#

有一些问题：不同的微服务一般会有不同的网络地址，客户端在访问这些微服务时必须记住几十甚至几百个地址，这对于客户端方来说太复杂也难以维护。

6、抓取数据

Sat, 11 Nov 2023 00:00:00 +0000

常用的抓取数据的姿势
#

姿势1：HTMLParser
姿势2：HttpClient
姿势3：Jsoup

Jsoup
#

1、添加依赖
#

<dependency>
    <groupId>org.jsoup</groupId>
    <artifactId>jsoup</artifactId>
    <version>1.13.1</version>
</dependency>

2、代码
#

@Test
public void test5() throws Exception {
    String url = "https://kns.cnki.net/kcms/detail/detail.aspx?dbcode=CJFD&dbname=CJFDAUTODAY&filename=SAHG202109022&uniplatform=NZKPT";
    //解析资源路径,设置超时时间30秒
    //此方法生成一个Document对象，可以按照前端方式进行操作
    Document doc = Jsoup.parse(new URL(url), 30000);
    //获取标题
    Element element = doc.getElementsByClass("wx-tit").get(0);
    String title = element.child(0).text();
    System.out.println("标题：" + title);

    //获取摘要
    Element chDivSummary = doc.getElementById("ChDivSummary");
    String digest = chDivSummary.text();
    System.out.println("摘要：" + digest);

    //获取关键字
    Element keywords = doc.getElementsByClass("keywords").get(0);
    int num = keywords.childNodeSize();
    String keyword = "";
    for (int i = 0; i < num; i++) {
        keyword += keywords.child(i).text();
    }
    System.out.println("关键字：" + keyword);
}

7、Transaction

Fri, 19 Jan 2024 00:00:00 +0000

事务
#

事务在逻辑上是一组操作，要么执行，要不都不执行。主要是针对数据库而言的，比如说 MySQL。事务是恢复和并发控制的基本单位。

7、面向对象编程（下）

Fri, 19 Jan 2024 00:00:00 +0000

interface接口
#

接口，实际上可以看做是一种规范

7、命令行参数

Thu, 04 Jan 2024 00:00:00 +0000

SpringBoot项目启动时，通过命令行，传入运行参数的方法

7、FreeMarker

Fri, 22 Dec 2023 00:00:00 +0000

FreeMarker
#

FreeMarker 是一款免费的模板引擎：即一种基于模板和要改变的数据，并用来生成输出文本(HTML网页，电子邮件，配置文件，源代码等)的通用工具。它不是面向最终用户的，而是一个Java类库，是一款程序员可以嵌入他们所开发产品的组件，也可以通过模板来生成Word、pdf、Excel

7、Listener

Sat, 11 Nov 2023 00:00:00 +0000

Listener
#

监听器，是JavaWeb三大组件之一，用于监听JavaWeb程序中的事件，例如创建、修改、删除Session、request、context等，并触发响应事件

7、比较器

Sat, 11 Nov 2023 00:00:00 +0000

自然排序：java.lang.Comparable

定制排序：java.util.Comparator

7、反射机制

Sat, 11 Nov 2023 00:00:00 +0000

反射的理解
#

Reflection（反射）被视为动态语言的关键，反射机制允许程序在**执行期（Runtime）**借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

7、服务配置中心

Sat, 11 Nov 2023 00:00:00 +0000

Config
#

Config叫配置中心，它的作用：帮助整个微服务系统，统一的管理配置文件

8、异常处理

Wed, 12 Feb 2025 00:00:00 +0000

异常的体系结构
#

java.lang.Throwable
- java.lang.Error：一般不编写针对性的代码进行处理，发生后，会直接导致JVM不可处理。
- java.lang.Exception：可以进行异常的处理
  - 编译时异常(checked受检异常)
    - IOException
      - FileNotFoundException
    - ClassNotFoundException
  - 运行时异常(unchecked非受检异常，RuntimeException)
    - NullPointerException
    - ArrayIndexOutOfBoundsException
    - ClassCastException
    - NumberFormatException
    - InputMismatchException
    - ArithmeticException

8、注解

Fri, 13 Dec 2024 00:00:00 +0000

什么是注解
#

注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。

8、验证码

Wed, 11 Dec 2024 00:00:00 +0000

SpringBoot集成kaptcha实现数字计算验证码和字母验证码功能
#

1、Maven依赖
#

<dependency>
  <groupId>pro.fessional</groupId>
  <artifactId>kaptcha</artifactId>
  <version>2.3.3</version>
  <exclusions>
    <exclusion>
      <artifactId>servlet-api</artifactId>
      <groupId>javax.servlet</groupId>
    </exclusion>
  </exclusions>
</dependency>

2、配置类
#

package top.ygang.framework.config;

import java.util.Random;
import com.google.code.kaptcha.text.impl.DefaultTextCreator;

/**
 * 验证码文本生成器
 * @Author: yanggang
 * @Date: 
 */
public class KaptchaTextCreator extends DefaultTextCreator
{
    private static final String[] CNUMBERS = "0,1,2,3,4,5,6,7,8,9,10".split(",");

    @Override
    public String getText()
    {
        Integer result = 0;
        Random random = new Random();
        int x = random.nextInt(10);
        int y = random.nextInt(10);
        StringBuilder suChinese = new StringBuilder();
        int randomoperands = random.nextInt(3);
        if (randomoperands == 0)
        {
            result = x * y;
            suChinese.append(CNUMBERS[x]);
            suChinese.append("*");
            suChinese.append(CNUMBERS[y]);
        }
        else if (randomoperands == 1)
        {
            if ((x != 0) && y % x == 0)
            {
                result = y / x;
                suChinese.append(CNUMBERS[y]);
                suChinese.append("/");
                suChinese.append(CNUMBERS[x]);
            }
            else
            {
                result = x + y;
                suChinese.append(CNUMBERS[x]);
                suChinese.append("+");
                suChinese.append(CNUMBERS[y]);
            }
        }
        else
        {
            if (x >= y)
            {
                result = x - y;
                suChinese.append(CNUMBERS[x]);
                suChinese.append("-");
                suChinese.append(CNUMBERS[y]);
            }
            else
            {
                result = y - x;
                suChinese.append(CNUMBERS[y]);
                suChinese.append("-");
                suChinese.append(CNUMBERS[x]);
            }
        }
        suChinese.append("=?@" + result);
        return suChinese.toString();
    }
}

package top.ygang.huijifindresource.utils.captcha;

import com.google.code.kaptcha.impl.DefaultKaptcha;
import com.google.code.kaptcha.util.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Properties;

import static com.google.code.kaptcha.Constants.*;

/**
 * @Description: 验证码配置
 * @Author: yanggang
 * @Date: 
 */
@Configuration
public class CaptchaConfig {


    /**
     * 字符验证码生成器
     * @return
     */
    @Bean(name = "captchaProducer")
    public DefaultKaptcha getKaptchaBean()
    {
        DefaultKaptcha defaultKaptcha = new DefaultKaptcha();
        Properties properties = new Properties();
        // 是否有边框 默认为true 我们可以自己设置yes，no
        properties.setProperty(KAPTCHA_BORDER, "yes");
        // 验证码文本字符颜色 默认为Color.BLACK
        properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_COLOR, "black");
        // 验证码图片宽度 默认为200
        properties.setProperty(KAPTCHA_IMAGE_WIDTH, "160");
        // 验证码图片高度 默认为50
        properties.setProperty(KAPTCHA_IMAGE_HEIGHT, "60");
        // 验证码文本字符大小 默认为40
        properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_SIZE, "38");
        // KAPTCHA_SESSION_KEY
        properties.setProperty(KAPTCHA_SESSION_CONFIG_KEY, "kaptchaCode");
        // 验证码文本字符长度 默认为5
        properties.setProperty(KAPTCHA_TEXTPRODUCER_CHAR_LENGTH, "4");
        // 验证码文本字体样式 默认为new Font("Arial", 1, fontSize), new Font("Courier", 1, fontSize)
        properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_NAMES, "Arial,Courier");
        // 图片样式 水纹com.google.code.kaptcha.impl.WaterRipple 鱼眼com.google.code.kaptcha.impl.FishEyeGimpy 阴影com.google.code.kaptcha.impl.ShadowGimpy
        properties.setProperty(KAPTCHA_OBSCURIFICATOR_IMPL, "com.google.code.kaptcha.impl.ShadowGimpy");
        Config config = new Config(properties);
        defaultKaptcha.setConfig(config);
        return defaultKaptcha;
    }

    /**
     * 数学验证码生成器
     * @return
     */
    @Bean(name = "captchaProducerMath")
    public DefaultKaptcha getKaptchaBeanMath()
    {
        DefaultKaptcha defaultKaptcha = new DefaultKaptcha();
        Properties properties = new Properties();
        // 是否有边框 默认为true 我们可以自己设置yes，no
        properties.setProperty(KAPTCHA_BORDER, "yes");
        // 边框颜色 默认为Color.BLACK
        properties.setProperty(KAPTCHA_BORDER_COLOR, "105,179,90");
        // 验证码文本字符颜色 默认为Color.BLACK
        properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_COLOR, "blue");
        // 验证码图片宽度 默认为200
        properties.setProperty(KAPTCHA_IMAGE_WIDTH, "160");
        // 验证码图片高度 默认为50
        properties.setProperty(KAPTCHA_IMAGE_HEIGHT, "60");
        // 验证码文本字符大小 默认为40
        properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_SIZE, "35");
        // KAPTCHA_SESSION_KEY
        properties.setProperty(KAPTCHA_SESSION_CONFIG_KEY, "kaptchaCodeMath");
        // 验证码文本生成器
        // !!注意，这里需要手动修改为上面的KaptchaTextCreator的全类名
        properties.setProperty(KAPTCHA_TEXTPRODUCER_IMPL, "top.ygang.framework.config.KaptchaTextCreator");
        // 验证码文本字符间距 默认为2
        properties.setProperty(KAPTCHA_TEXTPRODUCER_CHAR_SPACE, "3");
        // 验证码文本字符长度 默认为5
        properties.setProperty(KAPTCHA_TEXTPRODUCER_CHAR_LENGTH, "6");
        // 验证码文本字体样式 默认为new Font("Arial", 1, fontSize), new Font("Courier", 1, fontSize)
        properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_NAMES, "Arial,Courier");
        // 验证码噪点颜色 默认为Color.BLACK
        properties.setProperty(KAPTCHA_NOISE_COLOR, "white");
        // 干扰实现类
        properties.setProperty(KAPTCHA_NOISE_IMPL, "com.google.code.kaptcha.impl.NoNoise");
        // 图片样式 水纹com.google.code.kaptcha.impl.WaterRipple 鱼眼com.google.code.kaptcha.impl.FishEyeGimpy 阴影com.google.code.kaptcha.impl.ShadowGimpy
        properties.setProperty(KAPTCHA_OBSCURIFICATOR_IMPL, "com.google.code.kaptcha.impl.ShadowGimpy");
        Config config = new Config(properties);
        defaultKaptcha.setConfig(config);
        return defaultKaptcha;
    }
}

3、工具类
#

package top.ygang.huijifindresource.utils.captcha;

import com.google.code.kaptcha.Producer;
import lombok.Data;
import org.apache.tomcat.util.codec.binary.Base64;
import org.springframework.stereotype.Component;
import org.springframework.util.FastByteArrayOutputStream;

import javax.annotation.Resource;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.IOException;

/**
 * @Description: 验证码生成工具类
 * @Author: yanggang
 * @Date: 
 */
@Component
public class CaptchaGenerateUtil {


    @Resource(name = "captchaProducer")
    private Producer captchaProducer;

    @Resource(name = "captchaProducerMath")
    private Producer captchaProducerMath;

    private static final String BASE64_IMG_PREFIX = "data:image/gif;base64,";

    @Data
    public static class CodeEntity {
        public CodeEntity(String code,String img){
            this.code = code;
            this.img = img;
        }
        //生成的验证码，存入缓存中，用于后续校验
        private String code;

        //生成的图片Base64编码,用于前端展示
        private String img;

    }

    /**
     * 生成字符验证码
     * @return
     * @throws IOException
     */
    public CodeEntity generateCode() throws IOException {
        String capStr = captchaProducer.createText();
        String code = capStr;
        BufferedImage image = captchaProducer.createImage(capStr);
        // 转换流信息写出
        FastByteArrayOutputStream os = new FastByteArrayOutputStream();
        ImageIO.write(image, "jpg", os);
        return new CodeEntity(code, BASE64_IMG_PREFIX + Base64.encodeBase64String(os.toByteArray()));
    }

    /**
     * 生成数学验证码
     * @return
     * @throws IOException
     */
    public CodeEntity generateCodeMath() throws IOException {
        String capText = captchaProducerMath.createText();
        String capStr = capText.substring(0, capText.lastIndexOf("@"));
        String code = capText.substring(capText.lastIndexOf("@") + 1);
        BufferedImage image = captchaProducerMath.createImage(capStr);
        // 转换流信息写出
        FastByteArrayOutputStream os = new FastByteArrayOutputStream();
        ImageIO.write(image, "jpg", os);
        return new CodeEntity(code, BASE64_IMG_PREFIX + Base64.encodeBase64String(os.toByteArray()));
    }
}

8、日志

Fri, 29 Nov 2024 00:00:00 +0000

Spring Boot默认使用SLF4J作为日志门面，并集成了Logback作为日志实现。SLF4J（Simple Logging Facade for Java）是一个通用的日志抽象层，可以与多种日志框架结合使用，如Logback、Log4j、Java Util Logging（JUL）等。Logback是一个快速、灵活且功能强大的日志框架，是Log4j的继任者。

8、文件上传下载

Mon, 11 Dec 2023 00:00:00 +0000

文件上传
#

Fileupload组件
#

专门用于实现文件上传下载的免费组件

8、数学

Sat, 11 Nov 2023 00:00:00 +0000

java.lang.Math
#

提供了一系列静态方法用于科学计算。

9、全局异常处理

Wed, 12 Feb 2025 00:00:00 +0000

全局异常处理
#

参数校验失败或业务操作抛出的异常，当然不可能再去手动捕捉异常进行处理，不然还不如用之前BindingResult方式呢。又不想手动捕捉这个异常，又要对这个异常进行处理，那正好使用SpringBoot全局异常处理来达到一劳永逸的效果！

9、类加载器

Fri, 19 Jan 2024 00:00:00 +0000

JVM执行加载结构
#

9、单元测试

Thu, 14 Dec 2023 00:00:00 +0000

Java中的JUnit单元测试
#

Java原生并没有提供单元测试的方法，一般的简单测试使用main方法进行测试，但是如果对于复杂的测试，则需要使用第三方框架来实现，例如JUnit框架

10、SpringBoot生命周期

Wed, 12 Feb 2025 00:00:00 +0000

10、加密算法

Mon, 09 Dec 2024 00:00:00 +0000

加密方式
#

对称加密：客户端和服务器共用同一个密钥，可以用于加密一段内容，可以用于解密这段内容。
- 优点：加解密效率高。
- 缺点：安全性方面可能存在一些问题，因为密钥存放在客户端有被窃取的风险
- 对称加密的代表算法有：AES、DES等。
非对称加密：它将密钥分成了两种（公钥和私钥）。公钥通常存放在客户端，私钥通常存放在服务器。使用公钥加密的数据只有用私钥才能解密，反过来使用私钥加密的数据也只有用公钥才能解密。
- 优点：是安全性更高，因为客户端发送给服务器的加密信息只有用服务器的私钥才能解密，因此不用担心被别人破解。
- 缺点：加解密的效率相比于对称加密要差很多。
- 非对称加密的代表算法有：RSA、ElGamal等。
哈希算法：它的作用是对任意长度的数据生成一个固定长度的唯一标识，也叫哈希值、散列值或消息摘要（后文统称为哈希值）。
- 优点：原始数据的任何改变都会导致哈希值的巨大变化。不能从哈希值还原出原始数据。一般用于密码的保存或者内容校验。
- 常见的算法有：MD5、SHA、SM3、Bcrypt等。

对称加密
#

对称加密是一种相对来说比较常用的加密方式，它的工作原理很简单：先用一个秘钥将明文加密成密文，再用相同的秘钥将密文解密成明文。其中最常见的对称加密算法有DES、3DES、AES。

10、JDBC

Fri, 19 Jan 2024 00:00:00 +0000

数据持久化
#

数据持久化就是将内存中的数据模型转换为存储模型，以及将存储模型转换为内存中的数据模型的统称。数据模型可以是任何数据结构或对象模型，存储模型可以是关系模型、XML、二进制流等。

10、JSON

Sat, 11 Nov 2023 00:00:00 +0000

JSON
#

JSON（JavaScript Object Notation，JS对象简谱）是一种轻量级的数据交换格式。它基于 ECMAScript（欧洲计算机协会制定的js规范）的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据，但是也使用了类似于 C 语言家族的习惯（包括 C, C++, C#, Java, JavaScript, Perl, Python 等）。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

11、常用命令

Wed, 03 Apr 2024 00:00:00 +0000

javac
#

javac 是java中的编译源代码的命令工具，将.java文件编译成.class文件

面试宝典

Thu, 04 Jan 2024 00:00:00 +0000

JavaSE基础
#

Java面向对象
#

»>面向对象有哪些特性，以及对这些特性的理解
#

封装、继承、多态、（抽象）

4.1、排序算法

Sat, 11 Nov 2023 00:00:00 +0000

冒泡排序
#

思想：
#

1、一个无序的数组，n个元素，一共需要排序n-1轮

Tomcat

Sat, 11 Nov 2023 00:00:00 +0000

Tomcat的缺省端口是多少，怎么修改
#

缺省端口是8080

并发编程

Sat, 11 Nov 2023 00:00:00 +0000

现有T1、T2、T3三个线程，你怎么保证T2在T1执行完后执行，T3在T2执行完后执行
#

可以在T1的start方法后添加T1.join方法，在T2的start方法后添加T2.join方法

集合

Sat, 11 Nov 2023 00:00:00 +0000

List
#

ArrayList
#

1、ArrayList用过吗，是什么东西，可以用来干嘛
#

用过，ArrayList就是数组列表，主要用来装在数据，当我们装在的是基本数据类型如int、long、boolean、short、byte时，只可以存储他们的包装类，他的底层实现是一个Object类型的数组，特点就是查询效率高，增删的效率低，线程不安全，但是使用的频率高

设计模式

Sat, 11 Nov 2023 00:00:00 +0000

列举在JDK中常用的设计模式
#

单例模式：用于Runtime，Calendar和其他的一些类中

数据库

Sat, 11 Nov 2023 00:00:00 +0000

1、数据库的三范式是什么
#

第一范式：表中字段具有原子性，不可再分

Java on 杨刚的个人网站

1、AWT

Java 图形化界面 #

1、SpringBoot

Spring Boot #

概念 #

1、Redis

数据库概述 #

1、Swagger

Swagger在线文档技术 #

参照的示例 #

1、Mybatis

Mybatis #

优点 #

缺点 #

简单使用 #

1、导入mybatis依赖 #

2、导入目标数据库的对应驱动 #

1、JVM与GC

JVM的空间 #

1、时间日期

java.lang.System #

1、JavaWeb与Tomcat

JavaEE #

1、Maven

Maven #

1、Spring

Spring概述 #

Spring的特点 #

Spring的优点 #

Spring体系结构 #

1、SpringMVC

SpringMVC #

1、SpringSecurity

什么是SpringSecurity #

1、ElasticSearch

全文检索 #

需求 #

1、JavaFX概述

JavaFX #

界面结构 #

1、java语言概述

java基础知识图解 #

1、JNA

JNI和JNA #

1、JVM和Java体系结构

JVM #

1、Nginx+Tomcat集群

Tomcat存在的问题 #

1、RabbitMQ

消息队列 #

1、Shiro

Shiro简介 #

Shiro能帮系统做什么 #

Shiro提供的10大功能 #

1、Stage

1、WebService

WebService简介 #

1、代理模式

原理 #

1、单例模式

要解决的问题： #

1、基于springboot项目构建

准备工作 #

1、枚举类

1、设计模式概述

1、微服务

微服务简介 #

2、settings.xml

settings.xml #

2、Swing

Swing 概念 #

2、集合

继承树 #

Collection接口 #

2、Thymeleaf

JSP的缺陷 #

模板引擎 #

Thymeleaf的特点 #

2、对数据库的操作

Java 图形化界面
#

Spring Boot
#

概念
#

数据库概述
#

Swagger在线文档技术
#

参照的示例
#

Mybatis
#

优点
#

缺点
#

简单使用
#

1、导入mybatis依赖
#

2、导入目标数据库的对应驱动
#

JVM的空间
#

java.lang.System
#

JavaEE
#

Maven
#

Spring概述
#

Spring的特点
#

Spring的优点
#

Spring体系结构
#

SpringMVC
#

什么是SpringSecurity
#

全文检索
#

需求
#

JavaFX
#

界面结构
#

java基础知识图解
#

JNI和JNA
#

JVM
#

Tomcat存在的问题
#

消息队列
#

Shiro简介
#

Shiro能帮系统做什么
#

Shiro提供的10大功能
#

WebService简介
#

原理
#

要解决的问题：
#

准备工作
#

微服务简介
#

settings.xml
#

Swing 概念
#

继承树
#

Collection接口
#

JSP的缺陷
#

模板引擎
#

Thymeleaf的特点
#

添加、删除、修改
#

添加数据并获取主键值
#

方式一
#

方式二
#

查询
#

简单查询
#

多表查询
#

一对一
#

Nginx的使用
#

Nginx启动
#

Nginx整合Tomcat，并实现动静分离（单个Tomcat）
#

修改nginx.conf文件
#

配置负载均衡（多个Tomcat）
#

IOC与DI
#

关键字与保留字
#

关键字
#

流程
#

简单使用
#

1、创建Web项目
#

整合SpringBoot+CXF
#

1、添加依赖
#

2、编写服务接口和服务实现类
#

3、编写配置类
#

4、启动类
#

5、访问浏览器查看wsdl
#

ELK
#

HTTP协议
#

准备工作
#

1、查看数据端口，默认5672
#

java.lang.Object
#

registerNatives()
#

javafx.application.Platform
#

通用命令
#

对String操作的命令
#