selenium基本用法实例

selenium是python的一个扩展包，通常用来自动化web测试或者爬虫



# selenium安装

```
pip install selenium
```

:::note{title="注"}
必须要下载浏览器对应版本的驱动包，放在python.exe同级目录，或者指定目录
:::

# selenium基本用法

```
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
@Date ：2023/12/24 16:21
强制等待， sleep，设置等待多长时间，就要等待多长时间。等待完成后，才会继续下一步：

智能等待， implicitly_wait所谓智能等待，就是在我设置的等待时间范围内，只要满足了我的条件，就会立即结束等待，继续往下进行，如果超时，则抛出异常。
 implicitly_wait也称之为隐性等待，不需要导入，直接使用webdriver对象调用。它主要执行两件事情，等待元素找到，执行命令。还以刚才的代码为例子，
 如果我们创建了webdriver对象之后，直接设置implicitly_wait等待，等待一旦设置，那么这个等会在浏览器对象的整个生命周期起作用：

显性等待, 相较于隐性等待，这个显性等待要明确等待条件和等待上限。比如隐性等待，只要元素存在，可找到就可以，但显性等待，我要明确条件是我的元素可见
'''
import time

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.wait import WebDriverWait #显性等待
from selenium.webdriver.support import expected_conditions as EC #显性等待


# 创建一个参数对象，用来控制chrome以无界面模式打开
chrome_options = Options()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--disable-gpu')

# 打开chrome浏览器
web = webdriver.Chrome(options=chrome_options)

# 智能等待，在设置时间范围内，只要条件成立，马上结束等待, implicitly_wait
chrome_driver.implicitly_wait(5)

# 打开携程网注册页面
web.get('https://passport.ctrip.com/user/reg/home')

print(web.page_source)# 打印源码
print(web.get_cookies())# 打印源码

# 使用显性等待， 等待元素id="TANGRAM__PSP_11__changeSmsCodeItem"加载到dom树中，等待上限是10s,每0.8秒去验证一下条件是否成立.
# driver：浏览器驱动,
# timeout：等待上限，单位是秒,
# poll_frequency：检测的轮询间隔，默认值是0.5秒,
# ignored_exceptions：超时后的抛出的异常信息，默认抛出NoSuchElementExeception异常
WebDriverWait(chrome_driver, 10, 0.8).until(EC.presence_of_element_located((By.ID,
 'TANGRAM__PSP_11__changeSmsCodeItem')))

# 发现点击元素并点击
web.find_element(By.XPATH,"/html/body/div[5]/div[3]/a[2]").click()

# 发现输入框先输入,后点击
web.find_element(By.XPATH,"/html/body/div[5]/div[3]/a[2]").send_keys("python",Keys.ENTER)

# 切换新窗口
web.switch_to.window(web.window_handles[-1])

#寻找数据，并得到数据
web_list = web.find_element(By.XPATH,"/html/body/div[5]/div[3]/a[2]")
for li in web_list:
 result = li.find_element(By.XPATH,"/html/body/div[5]/div[3]/a[2]").text
 print(result)

# 切换原来的窗口
web.switch_to.window(web.window_handles[0])

# 定位到下拉列表
sel = web.find_element(By.XPATH,"/html/body/div[5]/div[3]/a[2]")

#对元素进行包装
sel_list = Select(sel)
for i in range(len(sel_list)):
 sel_list.select_by_index(i)#按照索引进行切换
 time.sleep(2)
 # 发现输入框先输入,后点击
 tabel = web.find_element(By.XPATH,"/html/body/div[5]/div[3]/a[2]")
 print(tabel.text)


#关闭窗口
web.close()

#关闭浏览器
web.quit()
```

# selenium_get_cookies

```
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
@Date ：2023/12/24 19:00
pickle 是Python特有的序列化工具，能够快速高效存储Python数据类型，反序列化读取后返回的仍是原先的python数据类型。而.txt 等都是字符串类型，需要转换。
'''
import os
import pickle
import time

from selenium import webdriver
from selenium.webdriver.support.wait import WebDriverWait

brower = webdriver.Chrome()
wait = WebDriverWait(brower, 10)

def getTaobaoCookies():
 # get login taobao cookies
 url = "https://www.taobao.com/"
 brower.get("https://login.taobao.com/member/login.jhtml")
 while True:
 print("Please login in taobao.com!")
 time.sleep(3)
 # if login in successfully, url jump to www.taobao.com
 while brower.current_url == url:
 tbCookies = brower.get_cookies()
 brower.quit()
 cookies = {}
 for item in tbCookies:
 cookies[item['name']] = item['value']
 outputPath = open('taobaoCookies.pickle','wb')
 pickle.dump(cookies,outputPath)
 outputPath.close()
 return cookies
```

# selenium_make_cookies

```
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
@Date ：2023/12/24 19:01 
'''

#读取cookies 信息
def readTaobaoCookies():
 # if hava cookies file ,use it
 # if not , getTaobaoCookies()
 if os.path.exists('taobaoCookies.pickle'):
 readPath = open('taobaoCookies.pickle','rb')
 tbCookies = pickle.load(readPath)
 else:
 tbCookies = getTaobaoCookies()
 return tbCookies


#使用cookies
tbCookies = readTaobaoCookies()

brower.get("https://www.taobao.com")
for cookie in tbCookies:
 brower.add_cookie({
 "domain":".taobao.com",
 "name":cookie,
 "value":tbCookies[cookie],
 "path":'/',
 "expires":None
 })
brower.get("https://www.taobao.com")
```

# selenium_move

```
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
@Date ：2023/12/24 19:20 
'''
driver = webdriver.Chrome()
driver.get('https://www.baidu.com/')
driver.implicitly_wait(5)

# ------------------------------鼠标移动-------------------------------------------
# 定位设置元素
set_ele = driver.find_element_by_xpath("//div[@id='u1']//a[text()='设置']")
# 第一步：创建一个鼠标操作的对象
action = ActionChains(driver)
# 第二步：进行移动
action.move_to_element(set_ele)
# 第三步：执行动作
action.perform()

# 三行代码写成一行：支持链式调用
ActionChains(driver).move_to_element(set_ele).perform()

# 等待高级设置可点击
WebDriverWait(driver, 5, 0.2).until(
 EC.element_to_be_clickable((By.XPATH, "//a[text()='高级搜索']"))
).click()


# ------------------------------鼠标滑动-------------------------------------------
# 选择拖动滑块的节点
sli_ele = driver.find_element_by_id('tcaptcha_drag_thumb')
# ------------鼠标滑动操作------------
action = ActionChains(driver)
# 第一步：在滑块处按住鼠标左键
action.click_and_hold(sli_ele)
# 第二步：相对鼠标当前位置进行移动
action.move_by_offset(100,0)
# 第三步：释放鼠标
action.release()
# 执行动作
action.perform()


# ------------------------------鼠标拖动-------------------------------------------
s = WebDriverWait(driver, 30, 0.5).until(
 EC.visibility_of_element_located((By.ID, 'draggable'))
)
t = WebDriverWait(driver, 30, 0.5).until(
 EC.visibility_of_element_located((By.ID, 'droppable'))
)
# ------------鼠标滑动操作------------
action = ActionChains(driver)
# 第一步：拖动元素
action.drag_and_drop(s, t)
# 执行动作
action.perform()
```

# selenium_slider

```
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
@Date ：2023/12/22 12:32 
'''
import time

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains

# 打开chrome浏览器
web = webdriver.Chrome()
# chrome浏览器窗口最大化
web.maximize_window()
#隐性等待，在开头设置过之后，整个的程序运行过程中都会有效
web.implicitly_wait(10)

# 打开携程网注册页面
web.get('https://passport.ctrip.com/user/reg/home')

web.find_element(By.XPATH,"/html/body/div[5]/div[3]/a[2]").click()

# 点击同意并继续
# web.find_element(By.XPATH, '//div[@class="pop_footer"]/a[@class="reg_btn reg_agree"]').click()


# 定位到滑块按钮元素
# ele_button = web.find_element(By.XPATH, '//div[@class="cpt-drop-btn"]')
ele_button = web.find_element(By.XPATH, '/html/body/div[1]/div[2]/div/div[1]/div/dl[2]/dd/div/div[1]/div[2]')
# 打印滑块按钮的宽和高
print('滑块按钮的宽：', ele_button.size['width'])
print('滑块按钮的高：', ele_button.size['height'])
# 定位到滑块区域元素
# ele = web.find_element(By.XPATH, '//div[@class="cpt-bg-bar"]')
ele = web.find_element(By.XPATH, '/html/body/div[1]/div[2]/div/div[1]/div/dl[2]/dd/div')
# 打印滑块区域的宽和高
print('滑块区域的宽：', ele.size['width'])
print('滑块区域的高：', ele.size['height'])
# 拖动滑块
ActionChains(d).drag_and_drop_by_offset(ele_button, ele.size['width'], ele.size['height']).perform()

time.sleep(10)
```
:::note{title="注"}
文章如有错误，还望留言指正
:::
参考资料
特殊原因，不便展示，请见谅

selenium

爬虫基础

gradle的安装指南和基本使用



官网安装包 https://gradle.org/releases/
# gradle的安装指南
## 在linux安装
### 先决条件
已安装 JDK/JRE（版本 7 或以上）,在命令行输入：
```
java -version 
```
可查询当前已安装的版本

### 下载安装包，解压，自定义安装目录
```
wget https://downloads.gradle.org/distributions/gradle-4.6-bin.zip

unzip -d /opt/gradle gradle-4.6-bin.zip 
```
### 配置环境
```
vim /etc/profile

export GRADLE_HOME=/opt/gradle/gradle-4.6
export PATH=$PATH:$GRADLE_HOME/bin

#刷新环境变量
source /etc/profile
```
### 校验安装结果
```
gradle --version 
```
## 在windows安装
### 先决条件
已安装 JDK/JRE（版本 7 或以上），这里是 Win10 系统
在命令行输入：java -version 可查询当前电脑已安装的版本
### 下载
从 Gralde 官方网站下载 Gradle 的最新发行包。
### 解压，自定义安装目录
Gradle 发行包是一个 ZIP 文件。完整的发行包包括以下内容(官方发行包有 full 完整版，也有不带源码和文档的版本，可根据需求下载):
● Gradle 可执行文件
● 用户手册 (有 PDF 和 HTML 两种版本)
● DSL 参考指南
● API 手册(Javadoc 和 Groovydoc)
● 样例，包括用户手册中的例子，一些完整的构建样例和更加复杂的构建脚本
● 源代码。仅供参考使用,如果你想要自己来编译 Gradle 你需要从源代码仓库中检出发行版本源码，具体请查看 Gradle 官方主页。
下载后，解压放到一个单独的文件夹
### 配置环境变量
运行 gradle 必须将 GRADLE_HOME/bin 加入到你的 PATH 环境变量中，GRADLE_HOME为gradle的安装目录。
```
GRADLE_HOME //系统环境 gradle的安装根目录

%GRADLE_HOME%/bin //path环境 
```
### 测试安装
运行如下命令来检查是否安装成功.该命令会显示当前的 JVM 版本和 Gradle 版本。
```
gradle -v
```
# gradle的基本使用
## 创建新项目
### `gradle init` 初始化新项目
你可以使用 `gradle init` 命令来初始化一个新的 Gradle 项目。这将引导你完成项目的初始化过程，并生成必要的文件和目录结构。
```bash
gradle init --type java-application
```
这会创建一个简单的 Java 应用程序项目，包括以下内容：
- `build.gradle`：项目的主要构建脚本。
- `settings.gradle`：项目设置文件。
- `src/main/java`：源代码目录。
- `src/test/java`：测试代码目录。
### 编写 `build.gradle` 文件
在 `build.gradle` 文件中定义项目的依赖关系、插件和其他配置。以下是一个简单的示例：
```groovy
plugins {
 id 'java'
 id 'application'
}

repositories {
 mavenCentral()
}

dependencies {
 implementation 'org.slf4j:slf4j-api:1.7.30'
 testImplementation 'junit:junit:4.13'
}

application {
 mainClassName = 'com.example.Main'
}
```
- `plugins`：指定要使用的插件，例如 `java` 和 `application` 插件。
- `repositories`：指定依赖项的仓库位置，这里是 Maven Central。
- `dependencies`：列出项目所需的依赖项。
- `application`：配置应用程序的主类。
### 运行任务
Gradle 提供了许多内置任务，你可以通过以下命令查看所有可用的任务：
```bash
gradle tasks
```
常用的任务包括：
- **构建项目**：

```bash
gradle build
```

这将编译源代码、运行测试并打包项目。
- **运行应用程序**：
如果你使用了 `application` 插件，可以运行以下命令来启动应用程序：

```bash
gradle run
```
- **清理构建输出**：

```bash
gradle clean
```
- **运行测试**：

```bash
gradle test
```

## 添加依赖项
在 `build.gradle` 文件中的 `dependencies` 块中添加依赖项。例如，添加 JUnit 测试框架：
```groovy
dependencies {
 testImplementation 'junit:junit:4.13'
}
```
然后运行 `gradle build` 或 `gradle test` 来下载依赖项并执行相应的任务。
## 使用 Gradle Wrapper
Gradle Wrapper 是一个脚本，它可以确保在不同的开发环境中使用相同的 Gradle 版本。它通常包含在项目中，并且不需要开发者手动安装 Gradle。
### 初始化 Gradle Wrapper
如果你已经有一个 Gradle 项目，可以通过以下命令生成 Gradle Wrapper：
```bash
gradle wrapper
```
这会在项目根目录下生成以下文件：
- `gradlew`：Unix shell 脚本。
- `gradlew.bat`：Windows 批处理脚本。
- `gradle/wrapper/gradle-wrapper.jar`：Wrapper 的 JAR 文件。
- `gradle/wrapper/gradle-wrapper.properties`：Wrapper 配置文件。
### 使用 Gradle Wrapper 构建项目
使用生成的 Wrapper 脚本来执行 Gradle 任务：
```bash
./gradlew build
```
或者在 Windows 上：
```bash
gradlew.bat build
```
## gradle项目示例
假设我们创建了一个简单的 Java 应用程序项目，其结构如下：
```
my-app/
├── build.gradle
├── settings.gradle
└── src
 ├── main
 │ └── java
 │ └── com
 │ └── example
 │ └── Main.java
 └── test
 └── java
 └── com
 └── example
 └── MainTest.java
```

`build.gradle` 文件内容：

```groovy
plugins {
 id 'java'
 id 'application'
}

repositories {
 mavenCentral()
}

dependencies {
 implementation 'org.slf4j:slf4j-api:1.7.30'
 testImplementation 'junit:junit:4.13'
}

application {
 mainClassName = 'com.example.Main'
}
```

`Main.java` 文件内容：

```java
package com.example;

public class Main {
 public static void main(String[] args) {
 System.out.println("Hello, World!");
 }
}
```

`MainTest.java` 文件内容：

```java
package com.example;

import org.junit.Test;
import static org.junit.Assert.*;

public class MainTest {
 @Test
 public void testMain() {
 assertTrue(true);
 }
}
```
接下来，你可以使用以下命令构建和运行项目：

```bash
./gradlew build
./gradlew run
```
这些是 `Gradle` 的一些基本使用方法。通过 `Gradle`，你可以更高效地管理和构建 Java 或 Kotlin 项目，同时利用其强大的依赖管理和任务系统。
:::note{title="注"}
文章如有错误，还望留言指正
:::
参考资料 
来自ai生成

gradle的安装指南和基本使用

maven的安装指南和基本使用


官网下载地址 https://maven.apache.org/download.cgi
# maven的安装指南
## 在linux安装maven
### 1.下载
#下载maven
```
wget https://dlcdn.apache.org/maven/maven-3/3.9.6/binaries/apache-maven-3.9.6-bin.tar.gz --no-check-certificat

#解压
tar -zxvf apache-maven-3.9.6-bin.tar.gz
mv apache-maven-3.9.6 maven
mv maven /usr/local/
```

### 2.设置setting.xml文件
 找到setting.xml文件
1. 设置本地仓库路径
```

<localRepository>/usr/local/maven/localRepository</localRepository>
```
2. 指定阿里云私服下载依赖
```

<mirror>
 <id>alimaven</id>
 <name>aliyun maven</name>
 <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
 <mirrorOf>central</mirrorOf>
</mirror>
```
3. 限定maven项目默认的jdk版本
```

<profile> 
 <id>myjdk</id> 
 <activation> 
 <activeByDefault>true</activeByDefault> 
 <jdk>1.8</jdk> 
 </activation> 
 <properties> 
 <maven.compiler.source>1.8</maven.compiler.source> 
 <maven.compiler.target>1.8</maven.compiler.target>
 <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion> 
 </properties> 
</profile>
 

<activeProfiles>
 <activeProfile>myjdk</activeProfile>
</activeProfiles>
```
### 3.打开配置文件
```
#打开配置文件
vi /ect/profile

export MAVEN_HOME=/usr/local/maven
export PATH=$PATH:$MAVEN_HOME/bin

#刷新环境变量
source /etc/profile
```

## 在windows安装maven
### 1.下载
点击下面网址下载对应版本，解压后文件移动到对应文件夹
![image.png](/static/img/ec30a26699af03f0c00ce35e493af14d.image.webp)
### 2.设置setting.xml文件
找到文件夹中conf下的setting.xml文件
1. 设置本地仓库路径
```

<localRepository>D:\java\maven\localRepository</localRepository>
```
2. 指定阿里云私服下载依赖
```

<mirror>
 <id>alimaven</id>
 <name>aliyun maven</name>
 <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
 <mirrorOf>central</mirrorOf>
</mirror>
```
3. 限定maven项目默认的jdk版本
```

<profile> 
 <id>jdk-18</id> 
 <activation> 
 <activeByDefault>true</activeByDefault> 
 <jdk>1.8</jdk> 
 </activation> 
 <properties> 
 <maven.compiler.source>1.8</maven.compiler.source> 
 <maven.compiler.target>1.8</maven.compiler.target>
 <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion> 
 </properties> 
</profile>
```
 
### 3.配置maven系统环境
建议系统变量编辑
```
MAVEN_HOME //系统环境 maven安装根目录

%MAVEN_HOME%\bin //path环境

mvn -v //测试
```
# maven的基本使用
1. 常用打包命令
```
mvn clean package -Dmaven.test.skip=true		-- 跳过单测打包
mvn clean install -Dmaven.test.skip=true		-- 跳过单测打包，并把打好的包上传到本地仓库
mvn clean deploy -Dmaven.test.skip=true			-- 跳过单测打包，并把打好的包上传到远程仓库
```
2. maven命令
```
mvn -v //查看版本
mvn archetype:create //创建 Maven 项目 
mvn compile //编译源代码 
mvn test-compile //编译测试代码 
mvn test //运行应用程序中的单元测试 
mvn site //生成项目相关信息的网站 
mvn package //依据项目生成 jar 文件 
mvn install //在本地 Repository 中安装 jar 
mvn -Dmaven.test.skip=true //忽略测试文档编译 
mvn clean //清除目标目录中的生成结果 
mvn clean compile //将.java类编译为.class文件 
mvn clean package //进行打包 
mvn clean test //执行单元测试 
mvn clean deploy //部署到版本仓库 
mvn clean install //使其他项目使用这个jar,会安装到maven本地仓库中 
mvn archetype:generate //创建项目架构 
mvn dependency:list //查看已解析依赖 
mvn dependency:tree com.xx.xxx //看到依赖树 
mvn dependency:analyze //查看依赖的工具 
mvn help:system //从中央仓库下载文件至本地仓库 
mvn help:active-profiles //查看当前激活的profiles 
mvn help:all-profiles //查看所有profiles 
mvn help:effective -pom //查看完整的pom信息
```
3. 注意
maven 命令要在IDEA的Terminal窗口执行
执行maven命令需要当前目录有pom依赖，可以用cd命令切换目录

4. 打包时注意：
当mvn仓库里缺少jar包，同时又从中央仓库自动下载不下来的时候，就需要自己下载jar包然后放仓库里了，
但是有时候只是简单的把jar和source放仓库的文件夹下，并不管用，这个时候你可以用命令把jar把打进去：

```
mvn install:install-file -Dfile=D:\xxx.jar -DgroupId=commons-dbcp -DartifactId= commons-dbcp -Dversion= 1.4 -Dpackaging=jar
```
-Dfile 是存在本地磁盘里jar 的路径，后面的就不用说了吧！`install:install-file` 看清楚了这个`-file`跟install是连着的。

`mvn dependency:tree`命令解决jar包冲突
当项目出现jar包冲突时,用命令`mvn dependency:tree` 查看依赖情况
`mvn dependency:tree` 查看依赖树,查看包结构间的依赖
`mvn dependency:tree >d:/tmp` 把结果输出到文件，然后再pom.xml文件里排除掉冲突的jar包
:::note{title="注"}
文章如有错误，还望留言指正
:::
参考资料 
来自ai生成

maven的安装指南和基本使用

java的安装指南


# java的安装指南
官网 https://www.java.com/zh-CN/
## linux手动安装java
1. 下载java的jdk包（可修改java版本，具体前往官网查看）
```
#下载java安装包
wget https://download.oracle.com/java/17/latest/jdk-17_linux-x64_bin.tar.gz
```
解压
```
tar -zxvf jdk-17_linux-x64_bin.tar.gz

mv jdk-17.0.12 java
mv java /usr/local
```
2. 配置环境变量

```
#打开配置文件
vi /etc/profile


export JAVA_HOME=/usr/local/java
export PATH=$PATH:$JAVA_HOME/bin;
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar;
exportPATH=${JAVA_HOME}/bin:$PATH

#刷新环境变量
source /etc/profile
```
## 在ubuntu/debain安装java
1. ubuntu正式安装

```
#ubuntu更新
sudo apt update

安装Java 8 (OpenJDK 8)
sudo apt install openjdk-8-jdk

安装Java 11 (OpenJDK 11)
sudo apt install openjdk-11-jdk
```
2. 验证Java安装
安装完成后，验证Java是否正确安装：

```
java -version
```
## centos安装java
1. centos正式安装
```
#centos更新
sudo yum update

安装Java 8 (OpenJDK 8)
sudo yum install java-1.8.0-openjdk

安装Java 11 (OpenJDK 11)
sudo yum install java-11-openjdk
```
2. 验证Java安装
安装完成后，验证Java是否正确安装：
```
java -version
```
## windows安装java
1. 下载java安装包点击安装
官网下载地址 https://www.oracle.com/java/technologies/downloads
2. 配置环境变量

```
#-----在环境变量配置(不是path)-----
Java_Home java安装目录

#从Java5开始CLASSPATH默认就是当前路径，一般情况下就不需要再设定了。
#若使用Java5以前的版本，需要设置环境变量CLASSPATH(不是path)
CLASSPATH .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;


#----在path中配置-----
%JAVA_HOME%\bin
%Java_Home%\jre\bin
```
3.打开命令行工具

```
#打开命令窗口 输入java 回车
java

#输入javac 回车
javac

#查看java版本
Java -version
```
# java的基本使用
## linux
（1）直接启动，控制台退出则关掉应用
```
java -jar uap-register-server-1.0.0.jar
```
（2）后台启动，控制台退出不会关掉应用
```
nohup java -jar uap-register-server-1.0.0.jar &
```
（3）后台启动并且输出日志，控制台退出不会关掉应用
```
nohup java -jar uap-register-server-1.0.0.jar >> ./out.log 2>&1 &
```
（4）后台启动(加内存)并且输出日志，控制台退出不会关掉应用
```
nohup java -jar -Xms1024m -Xmx2048m uap-register-server-1.0.0.jar>> ./out.log 2>&1 &
```
## windows
（1）直接启动，控制台退出则关掉应用
```
java -jar uap-register-server-1.0.0.jar
```
（2）后台启动，控制台退出不会关掉应用
```
javaw -jar uap-register-server-1.0.0.jar
```
（3）后台启动并且输出日志，控制台退出不会关掉应用
```
javaw -jar myapp.jar > output.txt 2>&1
```
（4）创建一个bat文件启动并且输出日志，控制台退出不会关掉应用
```
@echo off
javaw -jar myapp.jar > output.txt 2>&1
```
:::note{title="注"}
文章如有错误，还望留言指正
:::
参考资料 来自ai生成