一. 介绍zookeeper
目标
了解Zookeeper的概念
了解分布式的概念
学习路径
Zookeeper概述
Zookeeper的发展历程
什么是分布式
Zookeeper的应用场景
1.1 zookeeper概述
Apache ZooKeeper的系统为分布式协调是构建分布式应用的高性能服务。
ZooKeeper 本质上是一个分布式的小文件存储系统。提供基于类似于文件系统的目录树方式的数据存储，并且可以对树中的节点进行有效管理。从而用来维护和监控你存储的数据的状态变化。通过监控这些数据状态的变化，从而可以达到基于数据的集群管理。
ZooKeeper 适用于存储和协同相关的关键数据，不适合用于大数据量存储。

一.Maven
1.1 Maven基础回顾
目标

回顾Maven基础课程

学习路径

Maven好处
安装配置Maven
三种仓库
常见命令
坐标的书写规范
如何添加坐标
依赖范围
1.1.1 回顾
什么是Maven

Maven 是专门用于构建和管理Java相关项目的工具。

Maven好处

节省磁盘空间
可以一键构建
可以跨平台
应用在大型项目时可以提高开发效率（jar包管理，maven的工程分解，可分模块开发）
安装配置 maven

三种仓库

本地仓库，远程仓库（私服）, 公司内部中央仓库

常见的命令

Compile
Test
Package（jar，war）
Install（安装到本地仓库）
Deploy（部署到远程仓库（私服））
Clean（target下生成的文件）
坐标的书写规范

groupId 公司或组织域名的倒序
artifactId 项目名或模块名
version 版本号
如何添加坐标

在本地仓库中搜索
互联网上搜，推荐网址 http://www.mvnrepository.com/
依赖范围

属性：

依赖范围 对于编译classpath有效 对于测试classpath有效 对于运行classpath有效 例子
Compile(默认) Y Y Y Spring-core
Test - Y - Junit
Provided Y Y - servlet-api
Runtime - Y Y JDBC驱动
System Y Y - 本地的，Maven仓库之外的类库
1.1.2 小结
Maven好处
安装配置Maven（熟练）
三种仓库（本地仓库(阿里镜像)，中央仓库（远程仓库），私服（代理仓库））
常见命令（clean compile test package install deploy）
坐标的书写规范（groupId artifactId version）
如何添加坐标（http://www.mvnrepository.com/）
依赖范围
私服的配置（settings.xml配置私服 工作中大概率要配置的）
1.2 Maven中jar包冲突问题
目标

使用maven依赖导入jar包，出现相同名称但版本不一致的jar包

学习路径

演示jar包冲突问题：遵循第一声明者优先原则
解决jar包冲突问题，路径近者优先
解决jar包冲突问题，直接排除法
首先创建一个Mavenjar包工程(New Project-Maven)

1.2.1 第一声明优先原则
哪个jar包在靠上的位置，这个jar包就是先声明的，先声明的jar包下的依赖包，可以优先引入项目中。

在pom.xml中引入如下坐标，分别是spring中不同的版本。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


4.0.0

com.test
Maven_Advanced
1.0-SNAPSHOT

jar

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-beans</artifactId>
  <version>4.2.4.RELEASE</version>
</dependency>

看看他们依赖包的导入，发现导入的包却没有问题，包使用的都是5.0.2的版本。

我们把上面2个包的顺序调换后就变成了低版本的依赖导入。

1.2.2 路径近者优先原则
直接依赖：项目中直接导入的jar包就是项目的直接依赖包。
传递依赖（间接依赖）：项目中没有直接导入的jar包，可以通过中直接依赖包传递到项目中去。
直接依赖比传递依赖路径近，最终进入项目的jar包会是路径近的直接依赖包。
修改jar包，直接引入依赖spring-core

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>

<!--引入直接依赖-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>4.2.8.RELEASE</version>
</dependency>

1.2.3 直接排除法
问题：整合项目需要用到5的版本，引入4的版本，会不会出现异常（类没有找到，方法没有找到）
当我们需要排除某个jar包的依赖时，在配置exclusions标签的时候，内部可以不写版本号。pom.xml依赖如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>

pom.xml添加exclusions

1
2
3
4
5
6


spring-core
org.springframework


1.2.4 小结
出现1个项目存在多个同种jar包的时候，需要我们进行解决maven的jar包冲突问题（异常：Class not found、Method not found等）

路径近者
节点路径相同时，使用第一声明优先（xml上下顺序有关）
无法通过依赖管理原则排除的，使用直接排除法
1.3 工程分层
之前项目开发：

工程分层后的开发：所有的service和dao的代码都在一起，1：增强程序的通用性，2：降低了代码的耦合性

目标

实现项目工程分解，掌握聚合和继承的作用

学习路径

聚合和继承
准备数据库环境
ssm_parent（父工程） pom 引入依赖
ssm_model（子工程） 实体类
ssm_dao（子工程） 数据库操作
ssm_service（子工程） 完业务操作
ssm_web（子工程） 收集请求参数，调用业务，返回结果给前端
测试（工程发布tomcat）
1.3.1 聚合（多模块）和继承
继承和聚合结构图：

特点1（继承）

ssm_parent父工程：存放项目的所有jar包。

ssm_web和ssm_service和ssm_dao有选择的继承jar包，并在工程中使用。这样可以消除jar包重复，并锁定版本

特点2（聚合）

ssm_web依赖于ssm_service，ssm_service依赖于ssm_dao，启动ssm_web，便可访问程序。

执行安装的时候，执行ssm_parent，就可以将所有的子工程全部进行安装。

理解继承和聚合总结

通常继承和聚合同时使用。

何为继承

继承是为了消除重复，如果将 dao、 service、 web 分开创建独立的工程则每个工程的 pom.xml 文件中的内容存在重复，比如：设置编译版本、锁定 spring 的版本的等，可以将这些重复的 配置提取出来在父工程的 pom.xml 中定义。

何为聚合

项目开发通常是分组分模块开发， 每个模块开发完成要运行整个工程需要将每个模块聚合在 一起运行，比如： dao、 service、 web 三个工程最终会打一个独立的 war 运行。

1.3.2 准备数据库环境
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
SET FOREIGN_KEY_CHECKS=0;

CREATE DATABASE Maven;
use Maven;
DROP TABLE IF EXISTS items;
CREATE TABLE items (
id int(10) NOT NULL auto_increment,
name varchar(20) default NULL,
price float(10,0) default NULL,
pic varchar(40) default NULL,
createTime datetime default NULL,
detail varchar(200) default NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

INSERT INTO items VALUES (‘1’, ‘Test01’, ‘1000’, null, ‘2018-03-13 09:29:30’, ‘带我走上人生巅峰’);
INSERT INTO items VALUES (‘2’, ‘Test02’, null, null, ‘2018-03-28 10:05:52’, ‘插入测试’);
INSERT INTO items VALUES (‘3’, ‘Test03’, ‘199’, null, ‘2018-03-07 10:08:04’, ‘插入测试’);
INSERT INTO items VALUES (‘7’, ‘Test04’, null, null, null, null);
INSERT INTO items VALUES (‘8’, ‘Test05’, null, null, null, null);
1.3.3 ssm_parent
创建ssm_parent的Maven Project
删除src文件夹
1.3.3.1 pom.xml
父工程：pom

详细信息
小结

pom
管理所有的jar包（并锁定版本）
父工程不需要开发的代码，src的文件夹可以删除
1.3.4 ssm_model
选择ssm_parent=>New->Moudle->Maven->创建子项目ssm_model(即实体类)

1.3.4.1 pom.xml
查看子工程pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15



ssm_parent
com.test
1.0-SNAPSHOT

4.0.0

<artifactId>ssm_model</artifactId>
<packaging>jar</packaging>

1
2
3

ssm_model

1.3.4.2 创建Items.java
1
2
3
4
5
6
7
8
9
public class Items {
private Integer id;
private String name;
private Float price;
private String pic;
private Date createTime;
private String detail;
//此处省略getter/setter，toString
}
小结
jar
管理项目中所有的实体类
1.3.5 ssm_dao
操作路径
配置pom.xml
创建spring-mybatis.xml（spring整合mybatis的配置）
创建ItemsDao.java
创建ItemsDao.xml
1.3.5.1 pom.xml
详细信息
查看父工程pom.xml

1
2
3
4

ssm_model
ssm_dao

1.3.5.2 创建spring-mybatis.xml
操作路径

设置数据库连接池
配置SqlSessionFactoryBean
添加Dao层接口扫描，让Dao被spring管理
spring-mybatis.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<!--2.配置sqlSessionFactoryBean-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!--配置数据源-->
    <property name="dataSource" ref="dataSource"/>
    <!--别名配置-->
    <property name="typeAliases" value="com.test.domain"/>
</bean>

<!--3.dao接口扫描-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.test.dao"/>
</bean>

int save(Items items);

<artifactId>ssm_service</artifactId>


<!--jar包-->
<packaging>jar</packaging>

<!--依赖-->
<dependencies>
    <!--依赖dao-->
    <dependency>
        <groupId>com.test</groupId>
        <artifactId>ssm_dao</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>

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

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
    </dependency>
</dependencies>

<!--2.方式一：声明式事务配置-->
<tx:advice id="txAdvice" transaction-manager="txtManager">
    <!--配置传播特性属性-->
    <tx:attributes>
        <!--
            对应方法参与事务并且在事务下执行，事务隔离剂别使用默认隔离级别,发生异常需要事务回滚
        -->
      <tx:method name="add*" isolation="DEFAULT" propagation="REQUIRED" rollback-for="java.lang.Exception" />
      <tx:method name="insert*" isolation="DEFAULT" propagation="REQUIRED" rollback-for="java.lang.Exception" />
      <tx:method name="save*" isolation="DEFAULT" propagation="REQUIRED" rollback-for="java.lang.Exception" />
      <tx:method name="delete*" isolation="DEFAULT" propagation="REQUIRED" rollback-for="java.lang.Exception" />
      <tx:method name="update*" isolation="DEFAULT" propagation="REQUIRED" rollback-for="java.lang.Exception" />
      <tx:method name="edit*" isolation="DEFAULT" propagation="REQUIRED" rollback-for="java.lang.Exception" />
        <!--
            只读操作
        -->
        <tx:method name="*" read-only="true" />
    </tx:attributes>
</tx:advice>
 <!--AOP声明式事务配置（配置切入点，通知关联切入点）-->
<aop:config>
    <!--切点指点-->
    <aop:pointcut id="tranpointcut" expression="execution(* com.test.service.*.*(..))" />
    <!--配置通知-->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="tranpointcut" />
</aop:config>
<!--方式二：注解方式事务配置-->
<!--<tx:annotation-driven transaction-manager="txtManager"/>-->
<!--3.扫描service-->
<context:component-scan base-package="com.test.service"/>
<!--4.引入spring-mybatis.xml-->
<import resource="spring-mybatis.xml" />

void save(Items items);

@Override
public List<Items> findAll() {
    return itemsDao.findAll();
}

@Override
public void save(Items items) {
    itemsDao.save(items);
}

for (Items items : all) {
  System.out.println(items);
}

<!--导入springmvc-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
</dependency>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
</dependency>

<!--servletAPI -->
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>servlet-api</artifactId>
  <scope>provided</scope>
</dependency>

<dependency>
  <groupId>javax.servlet.jsp</groupId>
  <artifactId>jsp-api</artifactId>
  <scope>provided</scope>
</dependency>

<!--jstl表达式 -->
<dependency>
  <groupId>jstl</groupId>
  <artifactId>jstl</artifactId>
</dependency>

<!--2.springmvc核心控制器-->
<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <!--启动优先级-->
    <load-on-startup>1</load-on-startup>
</servlet>
<!--3.指定映射拦截-->
<servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

@Autowired
private ItemsService itemsService;

@GetMapping("/findAll")
public String findAll(Model model){
    List<Items> list = itemsService.findAll();
    for (Items items : list) {
        System.out.println(items);
    }
    model.addAttribute("list",list);
    return "list";
}

@PostMapping("/save")
public String  save(Items items){
    itemsService.save(items);
    return "redirect:/list/findAll";
}

一.linux基础
1.1 远程连接工具使用
在实际开发中，Linux服务器都在其他的地方，我们要通过windows客户端工具远程去连接Linux并操作 它，连接Linux的windows客户端工具有很多，企业中常用的有secureCRT、Putty、xshell、SSH Secure等。

1.2 Linux目录结构
root目录:超级管理员所在的目录，用~表示
home目录:普通用户所在的目录
usr目录:安装用户文件所在的目录
etc目录:Linux系统管理和配置文件所在的目录

1.3 文件夹(目录)操作命令
查看

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
ls

List directory contents.

• List files one per line:
  ls -1

• List all files, including hidden files:
  ls -a

• Long format list (permissions, ownership, size and modification date) of all files:
  ls -la

• Long format list with size displayed using human readable units (KB, MB, GB):
  ls -lh

• Long format list sorted by size (descending):
  ls -lS

• Long format list of all files, sorted by modification date (oldest first):
  ls -ltr
  跳转

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
cd

Change the current working directory.

• Go to the given directory:
  cd path/to/directory

• Go to home directory of current user:
  cd

• Go up to the parent of the current directory:
  cd ..

• Go to the previously chosen directory:
  cd -
  创建

1
2
3
4
5
6
7
8
9
mkdir

Creates a directory.

• Create a directory in current directory or given path:
  mkdir directory

• Create directories recursively (useful for creating nested dirs):
  mkdir -p path/to/directory
  搜索

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
find

Find files or directories under the given directory tree, recursively.

• Find files by extension:
  find root_path -name ‘*.ext’

• Find files by matching multiple patterns:
  find root_path -name ‘pattern_1‘ -or -name ‘pattern_2‘

• Find directories matching a given name, in case-insensitive mode:
  find root_path -type d -iname ‘lib‘

• Find files matching a path pattern:
  find root_path -path ‘/lib//*.ext’

• Find files matching a given pattern, excluding specific paths:
  find root_path -name ‘.py’ -not -path ‘/site-packages/*’

• Find files matching a given size range:
  find root_path -size +500k -size -10M

• Run a command for each file (use {} within the command to access the filename):
  find root_path -name ‘*.ext’ -exec wc -l {} ;

• Find files modified in the last 7 days, and delete them:
  find root_path -mtime -7 -delete
  修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

mv

Move or rename files and directories.

• Move files in arbitrary locations:
  mv source target

• Do not prompt for confirmation before overwriting existing files:
  mv -f source target

• Prompt for confirmation before overwriting existing files, regardless of file permissions:
  mv -i source target

• Do not overwrite existing files at the target:
  mv -n source target

• Move files in verbose mode, showing files after they are moved:
  mv -v source target
  剪切

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

mv

Move or rename files and directories.

• Move files in arbitrary locations:
  mv source target

• Do not prompt for confirmation before overwriting existing files:
  mv -f source target

• Prompt for confirmation before overwriting existing files, regardless of file permissions:
  mv -i source target

• Do not overwrite existing files at the target:
  mv -n source target

• Move files in verbose mode, showing files after they are moved:
  mv -v source target
  复制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
cp

Copy files and directories.

• Copy a file to another location:
  cp path/to/file.ext path/to/copy.ext

• Copy a file into another directory, keeping the filename:
  cp path/to/file.ext path/to/target_parent_directory

• Recursively copy a directory’s contents to another location (if the destination exists, the directory is copied inside it):
  cp -r path/to/directory path/to/copy

• Copy a directory recursively, in verbose mode (shows files as they are copied):
  cp -vr path/to/directory path/to/copy

• Copy text files to another location, in interactive mode (prompts user before overwriting):
  cp -i *.txt path/to/target_directory

• Dereference symbolic links before copying:
  cp -L link path/to/copy
  删除

1
2
3
4
5
6
7
8
9
rmdir

Removes a directory.

• Remove directory, provided it is empty. Use rm to remove not empty directories:
  rmdir path/to/directory

• Remove directories recursively (useful for nested dirs):
  rmdir -p path/to/directory
  1.4 文件操作命令
  创建

1
2
3
4
5
6
7
8
9
10
11
12
touch

Change a file access and modification times (atime, mtime).

• Create a new empty file(s) or change the times for existing file(s) to current time:
  touch filename

• Set the times on a file to a specific date and time:
  touch -t YYYYMMDDHHMM.SS filename

• Use the times from a file to set the times on a second file:
  touch -r filename filename2
  查看

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
cat

Print and concatenate files.

• Print the contents of a file to the standard output:
  cat file

• Concatenate several files into the target file:
  cat file1 file2 > target_file

• Append several files into the target file:
  cat file1 file2 >> target_file

• Number all output lines:
  cat -n file

• Display non-printable and whitespace characters (with M- prefix if non-ASCII):
  cat -v -t -e file

tail

Display the last part of a file.

• Show last ‘num’ lines in file:
  tail -n num file

• Show all file since line ‘num’:
  tail -n +num file

• Show last ‘num’ bytes in file:
  tail -c num file

• Keep reading file until Ctrl + C:
  tail -f file

• Keep reading file until Ctrl + C, even if the file is rotated:
  tail -F file

head

Output the first part of files.

• Output the first few lines of a file:
  head -n count_of_lines filename

• Output the first few bytes of a file:
  head -c number_in_bytes filename
  删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
rm

Remove files or directories.

• Remove files from arbitrary locations:
  rm path/to/file path/to/another/file

• Recursively remove a directory and all its subdirectories:
  rm -r path/to/directory

• Forcibly remove a directory, without prompting for confirmation or showing error messages:
  rm -rf path/to/directory

• Interactively remove multiple files, with a prompt before every removal:
  rm -i file(s)

• Remove files in verbose mode, printing a message for each removed file:
  rm -v path/to/directory/*
  编辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
vim

Vim (Vi IMproved), a command-line text editor, provides several modes for different kinds of text manipulation.
Pressing i enters edit mode. <Esc> goes back to normal mode, which doesn’t allow regular text insertion.
More information: https://www.vim.org.

• Open a file:
  vim path/to/file

• View Vim’s help manual:
  :help

• Save a file:
  :write

• Quit without saving:
  :quit!

• Open a file at a specified line number:
  vim +line_number path/to/file

• Undo the last operation:
  u

• Search for a pattern in the file (press n/N to go to next/previous match):
  /search_pattern

• Perform a regex substitution in the whole file:
  :%s/pattern/replacement/g
  1.5 文件压缩命令
  将文件打成压缩包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
tar

Archiving utility.
Often combined with a compression method, such as gzip or bzip.
More information: https://www.gnu.org/software/tar.

• Create an archive from files:
  tar cf target.tar file1 file2 file3

• Create a gzipped archive:
  tar czf target.tar.gz file1 file2 file3

• Create a gzipped archive from a directory using relative paths:
  tar czf target.tar.gz -C path/to/directory .

• Extract a (compressed) archive into the current directory:
  tar xf source.tar[.gz|.bz2|.xz]

• Extract an archive into a target directory:
  tar xf source.tar -C directory

• Create a compressed archive, using archive suffix to determine the compression program:
  tar caf target.tar.xz file1 file2 file3

• List the contents of a tar file:
  tar tvf source.tar

• Extract files matching a pattern:
  tar xf source.tar –wildcards “*.html”

• Extract a specific file without preserving the folder structure:
  tar xf source.tar source.tar/path/to/extract –strip-components=depth_to_strip
  解压缩包获得文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
tar

Archiving utility.
Often combined with a compression method, such as gzip or bzip.
More information: https://www.gnu.org/software/tar.

• Create an archive from files:
  tar cf target.tar file1 file2 file3

• Create a gzipped archive:
  tar czf target.tar.gz file1 file2 file3

• Create a gzipped archive from a directory using relative paths:
  tar czf target.tar.gz -C path/to/directory .

• Extract a (compressed) archive into the current directory:
  tar xf source.tar[.gz|.bz2|.xz]

• Extract an archive into a target directory:
  tar xf source.tar -C directory

• Create a compressed archive, using archive suffix to determine the compression program:
  tar caf target.tar.xz file1 file2 file3

• List the contents of a tar file:
  tar tvf source.tar

• Extract files matching a pattern:
  tar xf source.tar –wildcards “*.html”

• Extract a specific file without preserving the folder structure:
  tar xf source.tar source.tar/path/to/extract –strip-components=depth_to_strip
  1.6 文件权限命令
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  chmod

Change the access permissions of a file or directory.

• Give the [u]ser who owns a file the right to e[x]ecute it:
  chmod u+x file

• Give the [u]ser rights to [r]ead and [w]rite to a file/directory:
  chmod u+rw file_or_directory

• Remove e[x]ecutable rights from the [g]roup:
  chmod g-x file

• Give [a]ll users rights to [r]ead and e[x]ecute:
  chmod a+rx file

• Give [o]thers (not in the file owner’s group) the same rights as the [g]roup:
  chmod o=g file

• Remove all rights from [o]thers:
  chmod o= file

• Change permissions recursively giving [g]roup and [o]thers the abililty to [w]rite:
  chmod -R g+w,o+w directory
  1.7 其他命令
  显示工作目录

1
2
3
4
5
6
7
8
9
pwd

Print name of current/working directory.

• Print the current directory:
  pwd

• Print the current directory, and resolve all symlinks (i.e. show the “physical” path):
  pwd -P
  查看进程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
ps

Information about running processes.

• List all running processes:
  ps aux

• List all running processes including the full command string:
  ps auxww

• Search for a process that matches a string:
  ps aux | grep string

• List all processes of the current user in extra full format:
  ps –user $(id -u) -F

• List all processes of the current user as a tree:
  ps –user $(id -u) f

• Get the parent pid of a process:
  ps -o ppid= -p pid
  杀死进程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
kill

Sends a signal to a process, usually related to stopping the process.
All signals except for SIGKILL and SIGSTOP can be intercepted by the process to perform a clean exit.

• Terminate a program using the default SIGTERM (terminate) signal:
  kill process_id

• List available signal names (to be used without the SIG prefix):
  kill -l

• Terminate a background job:
  kill %job_id

• Terminate a program using the SIGHUP (hang up) signal. Many daemons will reload instead of terminating:
  kill -1|HUP process_id

• Terminate a program using the SIGINT (interrupt) signal. This is typically initiated by the user pressing Ctrl + C:
  kill -2|INT process_id

• Signal the operating system to immediately terminate a program (which gets no chance to capture the signal):
  kill -9|KILL process_id

• Signal the operating system to pause a program until a SIGCONT (“continue”) signal is received:
  kill -17|STOP process_id

• Send a SIGUSR1 signal to all processes with the given GID (group id):
  kill -SIGUSR1 -group_id
  搜索

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
grep

Matches patterns in input text.
Supports simple patterns and regular expressions.

• Search for an exact string:
  grep search_string path/to/file

• Search in case-insensitive mode:
  grep -i search_string path/to/file

• Search recursively (ignoring non-text files) in current directory for an exact string:
  grep -RI search_string .

• Use extended regular expressions (supporting ?, +, {}, () and |):
  grep -E ^regex$ path/to/file

• Print 3 lines of [C]ontext around, [B]efore, or [A]fter each match:
  grep -C|B|A 3 search_string path/to/file

• Print file name with the corresponding line number for each match:
  grep -Hn search_string path/to/file

• Use the standard input instead of a file:
  cat path/to/file | grep search_string

• Invert match for excluding specific strings:
  grep -v search_string
  管道

1
2
3
4
| ##管道符
管道只允许正确输出通过
tee ####复制一份输出
2>&1 | ####转换错误输出为正确再通过管道
关机

1
poweroff
重启

1
2
3
4
5
6
7
8
9
reboot

Reboot the system.

• Reboot immediately:
  sudo reboot

• Reboot immediately without gracefully shutting down:
  sudo reboot -q
  二.Linux网络
  2.1 网络服务
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  ifconfig

Network Interface Configurator.

• View network settings of an ethernet adapter:
  ifconfig eth0

• Display details of all interfaces, including disabled interfaces:
  ifconfig -a

• Disable eth0 interface:
  ifconfig eth0 down

• Enable eth0 interface:
  ifconfig eth0 up

• Assign IP address to eth0 interface:
  ifconfig eth0 ip_address

ip addr :CentOS7版本
修改网卡ip
vim /etc/sysconfig/network-scripts/ifcfg-ens33
概要信息
DEVICE=ens33 网卡名称
TYPE=Ethernet 网卡类型 以太网
ONBOOT=yes 是否开机就使用此网卡
BOOTPROTO=dhcp 启动网卡时指定获取IP地址的方式
IPADDR= ip地址
GATEWAY= 网关
NETMASK=255.255.255.0 子网掩码
DNS1= DNS服务器
重启网卡服务
systemctl status network 查看指定服务的状态
systemctl stop network 停止指定服务
systemctl start network 启动指定服务
systemctl restart network 重启指定服务
2.2 防火墙服务
2.2.1 防火墙设置
防火墙设置
开启防火墙 systemctl start firewalld
重启防火墙 systemctl restart firewalld
关闭防火墙 systemctl stop firewalld
设置开机启动 systemctl enable firewalld
停止并关闭开机启动 systemctl disable firewalld
查看防火墙状态 systemctl status firewalld 或者 firewall-cmd –state
查看防火墙开机时是否启动 systemctl list-unit-files | grep firewalld
2.2.2 端口设置
端口设置
添加 firewall-cmd –zone=public –add-port=80/tcp –permanent
更新防火墙规则 firewall-cmd –reload
查看 firewall-cmd –zone=public –query-port=80/tcp
firewall-cmd –zone=public –list-ports
删除 firewall-cmd –zone=public –remove-port=80/tcp –permanent
常用端口 8080 tomcat
80 http协议
443 https协议
22 ssh远程连接
3306 mysql
6379 redis
三.Nginx
3.1 介绍
Nginx是一款轻量级的 Web 服务器,由俄罗斯的程序设计师伊戈尔·西索夫所开发。 Nginx性能非常优秀, 官方测试能够支撑5万并发链接，并且 cpu、内存等资源消耗却非常低，运行非常稳定。

Nginx的功能有很多，我们主要使用它来做静态资源服务器、负载均衡服务器和反向代理服务器。

3.2 应用场景
3.2.1 静态资源服务器
部署网站的静态资源(html、css、js),可与Tomcat等实现动静分离

3.2.2 反向代理服务器
代理

给某个对象提供一个代理对象，并由代理对象控制原对象的引用

正向代理

对客户端进行代理(例如VPN)

反向代理

对服务端进行代理

反向代理，就是对服务端进行代理，作为客户端,只需要将请求发送到反向代理服务器，由反向代理服务 器去选择目标服务器获取数据后，再响应给客户端，此时反向代理服务器和目标服务器对外就是一个服 务器，暴露的是代理服务器地址，隐藏了真实服务器IP地址。

3.2.3 负载均衡服务器
负载均衡 Load Balance 意思就是将一份负载分摊到多个操作单元上进行执行

3.3 配置文件介绍(nginx-1.13.9/conf/nginx.conf)
1
2
3
4
5
6
7
8
9
10
11
12
server {
listen 80; #port
server_name localhost; #Server

#charset koi8-r;

#access_log  logs/host.access.log  main;

location / {
    root   html; #Static resource directory
    index  index.html index.htm; #Default visit page
}

3.5 nginx与tomcat区别
存放的文件(资源)形式
Nginx是http服务器,只能解析静态文件

Tomcat是web中间件(本质上是一个servlet),能解析jsp和静态文件

用途

nginx可以作为反向代理服务器,负责均衡服务器,静态资源存放服务器

tomcat能作为jsp容器使用,静态资源存放服务器

性能

nginx支持5W+并发,tomcat的并发只能在200-400之间

总结

linux基础

Linux基本命令

目录结构

• root

​ - 超级管理员所在的目录

• home

​ - 普通用户所在的目录

• usr

​ - 安装用户文件所在的目录

• etc

​ - Linux系统管理和配置文件所在的目录

目录操作

• 查看

​ - ll

​ - ls

• 切换

​ - cd

​ - 绝对路径

​ - 相对路径

• 创建

​ - mkdir -p

• 修改/剪切

​ - mv

• 复制

​ - cp -r

• 删除

​ - rmdir -p

文件操作

• 创建

​ - touch

• 查看

​ - cat/more/less/head/tail

• 删除

​ - rm -rf

• 编辑

​ - vim

​ - 插入模式

​ - i

​ - 命令行模式

​ - esc

​ - 底行模式

​ - :

​ - wq!

​ - q!

压缩命令

• 打包

​ - tar -zcvf

​ - xxxx.tar.gz

• 解压缩

​ - tar -zxvf

​ - xxxx.tar.gz

文件权限

• chmod -R 777

其他命令

• 查看进程

​ - ps -ef

• 杀死进程

​ - kill -9 PID

• 文本搜索

​ - grep -in

• 管道

​ - 一个命令的输出作为另一个命令的输入

Linux网络

网络

• 查看ip

​ - ifconfig

​ - ip addr

防火墙

• 防火墙设置

​ - 关闭

​ - systemctl stop firewalld

​ - 关闭开机自启动

​ - systemctl disable firewalld

• 端口设置

​ - 放行端口

​ - firewall-cmd –zone=public –add-port=80/tcp –permanent

​ - 更新规则

​ - firewall-cmd –reload

Nginx

由战斗民族开发的一款高性能的 http 服务器/反向代理服务器

• http服务器

• 反向代理（负载均衡）

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

1.2 Maven能解决什么问题
一种工具，可以构建工程，管理 jar包，编译代码，还 能帮你自动运行单元测试，打包，生成报表，部署项目，生成 Web 站点。

1.3 Maven的两个核心功能
1.3.1 依赖管理
Maven的一个核心特性就是依赖管理。MVN依赖管理，就是一个管理jar包的过程

CRM项目
使用mvn工程实现 ➡项目中给定坐标，去仓库拉取jar包➡
索引的存在，使拉取jar包过程，可以认为是自己项目中有的 MVN仓库
jar的仓库
坐标:将来要找某个jar包，就是要确定这个jar包的坐标
jar包如何给出坐标:公司/组织名+项目名+版本号一起确定
maven工程中不直接将jar包导入到工程中，而是通过在pom.xml文件中添加所需jar包的坐标，避免了jar直接引入进来，在需要用到jar包的时候，只要查找pom.xml文件，再通过pom.xml文件中的坐标，到一个专门用于”存放jar包的仓库”(maven仓库)中根据坐标从而找到这些jar包，再把这些jar包拿去运行。

通过读取pom.xml 文件中的坐标，再到仓库中找到jar包，会不会很慢

通过pom.xml文件配置要引入的jar包的坐标，再读取坐标并到仓库中加载jar包，这样我们就可以直接使用jar包，为了解决这个过程中速度慢的问题，maven中也有索引的概念，通过建立索引，可以大大提高加载jar包的速度，使得我们认为jar包基本跟放在本地的工程文件中再读取出来的速度是一样的。

1.3.2 项目构建
什么是项目构建

项目从编译、测试、运行、打包、安装 ，部署整个过程都交给maven进行管理，这个过程称为构建。

一键构建 指的是整个构建过程，使用maven一个命令可以轻松完成整个工作。

Maven规范化构建流程

清理 ➡ 编译 ➡ 测试 ➡ 报告 ➡ 打包 ➡ 部署
二 Maven安装和使用
2.1 Maven下载和安装
2.1.1 Maven下载
Maven官网下载地址:http://maven.apache.org/download.cgi

目前使用@3.5版本

2.1.2 Maven安装
将apache-maven-3.5.2-bin.zip解压并添加至path

maven目录结构

目录 介绍
bin 存放了 maven 的命令
boot 存放了一些 maven 本身的引导程序，如类加载器等
conf 存放了 maven 的一些配置文件，如 setting.xml 文件
lib 存放了 maven 本身运行所需的一些 jar 包
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
apache-maven-3.5.2
├── LICENSE
├── NOTICE
├── README.txt
├── bin
│ ├── m2.conf
│ ├── mvn
│ ├── mvn.cmd
│ ├── mvnDebug
│ ├── mvnDebug.cmd
│ └── mvnyjp
├── boot
│ └── plexus-classworlds-2.5.2.jar
├── conf
│ ├── logging
│ ├── settings.xml
│ └── toolchains.xml
└── lib
├── aopalliance-1.0.jar
├── …省略
└── wagon-provider-api.license

7 directories, 91 files
2.1.3 Maven及JDK配置
Maven 3.3+ require JDK 1.7 or above to execute - they still allow you to build against 1.3 and other JDK versions by Using Toolchains

配置PATH

1
2
3
4
5
vi .zshrc

#MAVEN_HOME
export MAVEN_HOME=/Users/swzxsyh/Program/apache-maven-3.5.2
export PATH=$PATH:$MAVEN_HOME/bin
2.1.4 Maven软件版本测试
1
2
3
4
5
6
7
~ #mvn -v
Apache Maven 3.5.2 (138edd61fd100ec658bfa2d307c43b76940a5d7d; 2017-10-18T15:58:13+08:00)
Maven home: /Users/swzxsyh/Program/apache-maven-3.5.2
Java version: 1.8.0_221, vendor: Oracle Corporation
Java home: /Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre
Default locale: en_CN, platform encoding: UTF-8
OS name: “mac os x”, version: “10.15.4”, arch: “x86_64”, family: “mac”
2.3 Maven仓库
2.3.1 Maven仓库的分类
Maven仓库分为本地仓库和远程仓库二大类。而远程仓库又可分成中央仓库，私服，第三方仓库。

Maven仓库
本地仓库 远程仓库
⬇
中央仓库
私服
第三方公共库
依赖寻找流程

在本地仓库中，根据Maven坐标系寻找指定依赖，如果存在，直接返回。

如果Maven仓库中不存在，或者需要检查依赖的版本时，maven则会去远程仓库中寻找，下载到本地仓库中再使 用。

本地仓库

用来存储从远程仓库下载的插件和jar包，项目使用一些插件或jar包，优先从本地仓库查找。

中央仓库

在maven软件中内置一个远程仓库地址http://repo1.maven.org/maven2 ，它是中央仓库，服务于整个互联网，它是由Maven团队自己维护，里面存储了非常全的jar包，它包含了世界上大部分流行的开源项目构件。

第三方公共库

Maven 仓库默认中央仓库在国外且只有一个， 国内使用难免很慢，我们可以更换为第三方公共库，例如:阿里云镜 像。

私服

私服是一种特殊的远程仓库，其内容是来自于其他的远程仓库，一般架设在局域网内，提供给一个组织的人员使用。 当Maven需要下载依赖时，从私服请求，如果私服上不存在该依赖，则从其他远程仓库下载，同时缓存在私服上，提 供给其他人使用。如果项目中的一些内部模块，无法发布到外部远程仓库中，也可发布在私服上，提供给项目中的其 他人员使用。

2.3.2 Maven本地仓库的配置
1
2
3
4
5
6
7
8
9
10
11
12
13
cd $MAVEN_HOME/conf
vi settings.xml

找到

将/path/to/local/repo改为本地仓库路径添加到注释后
2.3.4 Maven仓库国内镜像配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21




alimaven
aliyun maven
http://maven.aliyun.com/nexus/content/groups/public/
central


2.3.4 全局setting与用户setting
maven仓库地址、私服等配置信息需要在setting.xml文件中配置，分为全局配置和用户配置。

在maven安装目录下 的有 conf/setting.xml文件，此setting.xml文件用于maven的所有project项目，它作为maven的全局配置。 如需要 个性配置则需要在用户配置中设置，用户配置的setting.xml文件默认的位置在:${user.dir} /.m2/settings.xml目录 中,${user.dir} 指windows 中的用户目录。

maven会先找用户配置，如果找到则以用户配置文件为准，否则使用全 局配置文件。

2.3 Maven坐标和依赖
Maven的一个核心的作用就是管理项目的依赖，引入我们所需的各种jar包等。为了能自动化的解析任何一个Java构 件，Maven必须将这些Jar包或者其他资源进行唯一标识，这是管理项目的依赖的基础，也就是我们要说的坐标。包 括我们自己开发的项目，也是要通过坐标进行唯一标识的，这样才能才其它项目中进行依赖引用。

坐标的定义元素如下

元素 作用
groupId 定义当前Maven项目名称
artifactId 定义项目模块
version 定义当前项目的当前版本
例如

创建一个Maven的web项目，在pom.xml文件中生成坐标

1
2
3
4
5

com.test
maven_helloword
1.0-SNAPSHOT
war
要引入junit的测试jar，只需要在pom.xml配置文件中配置引入junit的坐标依赖即可

1
2
3
4
5
6
7
8
9
10
11
12
13

1
2
3
4
├── maven_java.iml
├── pom.xml
├── src
└── target
进入src目录后，我们发现它里面的目录结构如下

1
2
3
4
5
6
7
8
9
10
src
├── main
│ ├── java #项目代码
│ ├── resources #配置文件
│ └── webapp #页面资源
└── test
├── java #测试代码
└──resources

6 directories, 0 files
文件 说明
src/main/java 存放项目的.java文件
src/main/resources 存放项目资源文件，如spring, mybatis配置文件
src/test/java 存放所有单元测试.java文件，如junit测试类
src/test/resources 测试资源文件
target 项目输出位置，编译后的class文件会输出到此目录
pom.xml maven项目核心配置文
注意:如果是普通的java项目，那么就没有webapp目录。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
完整java项目
java工程名（项目名）
|– src目录
|– main目录（主干代码）
|– java目录（java代码）
|– resources目录（配置文件）
|– test目录（测试代码）
|– java目录（java代码）
|– resources目录（配置文件）
|– pom.xml（maven工程核心配置文件）
|– target目录（存放编译后的class文件…..）

• web项目【重点】
  web工程名（项目名）
  |– src目录
  |– main目录（主干代码）
  |– java目录（java代码）
  |– resources目录（配置文件）
  |– webapp目录（页面资源）
  |– WEB-INF
  |– web.xml(web工程核心配置文件)
  |– index.jsp
  |– css、js、img..
  |– test目录（测试代码）
  |– java目录（java代码）
  |– resources目录（配置文件）
  |– pom.xml（maven工程核心配置文件）
  |– target目录（存放编译后的class文件…..）

2.4.2 Maven工程的运行
进入maven工程目录(当前目录有pom.xml文件)，运行tomcat7:run命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
~ mvn tomcat7:run

[INFO] Scanning for projects…
[INFO]
[INFO] ————————————————————————
[INFO] Building maven_web 1.0-SNAPSHOT
[INFO] ————————————————————————
[INFO]
[INFO] >>> tomcat7-maven-plugin:2.2:run (default-cli) > process-classes @ maven_web >>>
[INFO]
[INFO] — maven-resources-plugin:2.6:resources (default-resources) @ maven_web —
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
[INFO] — maven-compiler-plugin:3.1:compile (default-compile) @ maven_web —
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to /Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target/classes
[INFO]
[INFO] <<< tomcat7-maven-plugin:2.2:run (default-cli) < process-classes @ maven_web <<<
[INFO]
[INFO]
[INFO] — tomcat7-maven-plugin:2.2:run (default-cli) @ maven_web —
[INFO] Running war on http://localhost:8080/
[INFO] Creating Tomcat server configuration at /Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target/tomcat
[INFO] create webapp with contextPath:
May 15, 2020 10:29:37 PM org.apache.coyote.AbstractProtocol init
INFO: Initializing ProtocolHandler [“http-bio-8080”]
May 15, 2020 10:29:37 PM org.apache.catalina.core.StandardService startInternal
INFO: Starting service Tomcat
May 15, 2020 10:29:37 PM org.apache.catalina.core.StandardEngine startInternal
INFO: Starting Servlet Engine: Apache Tomcat/7.0.47
May 15, 2020 10:29:38 PM org.apache.coyote.AbstractProtocol start
INFO: Starting ProtocolHandler [“http-bio-8080”]
根据上边的提示信息,访问http://localhost:8080/ 即可

三.Maven生命周期和插件
3.1 Maven常用命令和插件
3.1.1 clean
clean是maven工程的清理命令，执行 clean会删除target目录及内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
~ mvn clean

[INFO] Scanning for projects…
[INFO]
[INFO] ————————————————————————
[INFO] Building maven_web 1.0-SNAPSHOT
[INFO] ————————————————————————
[INFO]
[INFO] — maven-clean-plugin:2.5:clean (default-clean) @ maven_web —
[INFO] Deleting /Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target
[INFO] ————————————————————————
[INFO] BUILD SUCCESS
[INFO] ————————————————————————
[INFO] Total time: 0.228 s
[INFO] Finished at: 2020-05-15T23:52:52+08:00
[INFO] Final Memory: 9M/309M
[INFO] ————————————————————————
3.1.2 compile
compile是maven工程的编译命令，作用是将src/main/java下的文件编译为class文件输出到target目录下。

将src中main目录下java代码进行编译，将src中main目录下配置抽取，输出到target目录: classes目录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
~ mvn compile

[INFO] Scanning for projects…
[INFO]
[INFO] ————————————————————————
[INFO] Building maven_web 1.0-SNAPSHOT
[INFO] ————————————————————————
[INFO]
[INFO] — maven-resources-plugin:2.6:resources (default-resources) @ maven_web —
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
[INFO] — maven-compiler-plugin:3.1:compile (default-compile) @ maven_web —
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to /Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target/classes
[INFO] ————————————————————————
[INFO] BUILD SUCCESS
[INFO] ————————————————————————
[INFO] Total time: 0.952 s
[INFO] Finished at: 2020-05-15T23:56:28+08:00
[INFO] Final Memory: 13M/209M
[INFO] ————————————————————————

～ ll ./target/classes/cn/itcast/web/servlet/

total 8
-rw-r–r– 1 swzxsyh staff 1.1K May 15 23:56 HelloServlet.class
3.1.3 test
test是maven工程的测试命令 mvn test，会执行src/test/java下的单元测试类，并编译为class文件。

mvn test=>target编译main代码=>编译test代码=>执行所有测试代码，类名xxxTest结尾，必须有@Test注解的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
~ mvn test

[INFO] Scanning for projects…
[INFO]
[INFO] ————————————————————————
[INFO] Building maven_web 1.0-SNAPSHOT
[INFO] ————————————————————————
[INFO]

#清理target目录
[INFO] — maven-resources-plugin:2.6:resources (default-resources) @ maven_web —
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
#编译src/main主干
[INFO] — maven-compiler-plugin:3.1:compile (default-compile) @ maven_web —
[INFO] Nothing to compile - all classes are up to date
[INFO]
#编译src/test测试目录
[INFO] — maven-resources-plugin:2.6:testResources (default-testResources) @ maven_web —
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
[INFO] — maven-compiler-plugin:3.1:testCompile (default-testCompile) @ maven_web —
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to /Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target/test-classes
[INFO]

针对test目录下的测试代码，逐一测试

[INFO] — maven-surefire-plugin:2.12.4:test (default-test) @ maven_web —
[INFO] Surefire report directory: /Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target/surefire-reports

T E S T S

Running cn.itcast.test.HelloTest
仅在测试期有效
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.065 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] ————————————————————————
[INFO] BUILD SUCCESS
[INFO] ————————————————————————
[INFO] Total time: 1.509 s
[INFO] Finished at: 2020-05-16T00:00:02+08:00
[INFO] Final Memory: 15M/212M
[INFO] ————————————————————————
3.1.4 package
package是maven工程的打包命令，对于java工程执行package打成jar包，对于web工程打成war包。

mvn package=>编译main代码=>编译test代码=>执行测试=>将项目打成war包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
~ mvn package

[INFO] Scanning for projects…
[INFO]
[INFO] ————————————————————————
[INFO] Building maven_web 1.0-SNAPSHOT
[INFO] ————————————————————————
[INFO]
[INFO] — maven-resources-plugin:2.6:resources (default-resources) @ maven_web —
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
[INFO] — maven-compiler-plugin:3.1:compile (default-compile) @ maven_web —
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] — maven-resources-plugin:2.6:testResources (default-testResources) @ maven_web —
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
[INFO] — maven-compiler-plugin:3.1:testCompile (default-testCompile) @ maven_web —
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] — maven-surefire-plugin:2.12.4:test (default-test) @ maven_web —
[INFO] Surefire report directory: /Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target/surefire-reports

T E S T S

Running cn.itcast.test.HelloTest
仅在测试期有效
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.048 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO]
[INFO] — maven-war-plugin:2.2:war (default-war) @ maven_web —
[INFO] Packaging webapp
[INFO] Assembling webapp [maven_web] in [/Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target/maven_web-1.0-SNAPSHOT]
[INFO] Processing war project
[INFO] Copying webapp resources [/Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/src/main/webapp]
[INFO] Webapp assembled in [49 msecs]
[INFO] Building war: /Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target/maven_web-1.0-SNAPSHOT.war
[INFO] WEB-INF/web.xml already added, skipping
[INFO] ————————————————————————
[INFO] BUILD SUCCESS
[INFO] ————————————————————————
[INFO] Total time: 1.528 s
[INFO] Finished at: 2020-05-16T00:05:14+08:00
[INFO] Final Memory: 12M/294M
[INFO] ————————————————————————

~ find . -name ‘*war’
./target/maven_web-1.0-SNAPSHOT.war
#此包可以直接放在tomcat的webapp下执行
注意：为什么maven_hello是war包而不是jar包呢？

1
2
3
cat pom.xml| grep -ri ‘packaging’
(standard input): war
#导包方式：jar默认，手动指定war
3.1.5 install
install是maven工程的安装命令，执行install将maven打成jar包或war包发布到本地仓库。

mvn install=>编译main代码=>编译test代码=>执行测试=>将项目打成war包=>安装到本地库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
~ mvn install

[INFO] Scanning for projects…
[INFO]
[INFO] ————————————————————————
[INFO] Building maven_web 1.0-SNAPSHOT
[INFO] ————————————————————————
[INFO]
[INFO] — maven-resources-plugin:2.6:resources (default-resources) @ maven_web —
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
[INFO] — maven-compiler-plugin:3.1:compile (default-compile) @ maven_web —
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] — maven-resources-plugin:2.6:testResources (default-testResources) @ maven_web —
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
[INFO] — maven-compiler-plugin:3.1:testCompile (default-testCompile) @ maven_web —
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] — maven-surefire-plugin:2.12.4:test (default-test) @ maven_web —
[INFO] Surefire report directory: /Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target/surefire-reports

T E S T S

Running cn.itcast.test.HelloTest
仅在测试期有效
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.053 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO]
[INFO] — maven-war-plugin:2.2:war (default-war) @ maven_web —
[INFO] Packaging webapp
[INFO] Assembling webapp [maven_web] in [/Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target/maven_web-1.0-SNAPSHOT]
[INFO] Processing war project
[INFO] Copying webapp resources [/Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/src/main/webapp]
[INFO] Webapp assembled in [32 msecs]
[INFO] Building war: /Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target/maven_web-1.0-SNAPSHOT.war
[INFO] WEB-INF/web.xml already added, skipping
[INFO]

将自己的代码，编译到本地仓库，之后可以上传到远程仓库，服务器自动下载部署

[INFO] — maven-install-plugin:2.4:install (default-install) @ maven_web —
[INFO] Installing /Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/target/maven_web-1.0-SNAPSHOT.war to /Users/swzxsyh/Program/repository/cn/itcast/maven_web/1.0-SNAPSHOT/maven_web-1.0-SNAPSHOT.war
[INFO] Installing /Users/swzxsyh/Downloads/Day54-maven基础&环境搭建/代码/maven_web/pom.xml to /Users/swzxsyh/Program/repository/cn/itcast/maven_web/1.0-SNAPSHOT/maven_web-1.0-SNAPSHOT.pom
[INFO] ————————————————————————
[INFO] BUILD SUCCESS
[INFO] ————————————————————————
[INFO] Total time: 1.522 s
[INFO] Finished at: 2020-05-16T00:08:09+08:00
[INFO] Final Memory: 12M/297M
[INFO] ————————————————————————
从运行结果中，可以看出: 当后面的命令执行时，前面的操作过程也都会自动执行

3.1.6 deploy
maven工程部署命令，将jar或war包部署（上传）到私服中。

3.2 Maven生命周期
maven对项目构建过程分为三套相互独立的生命周期，请注意这里说的是“三套”，而且“相互独立”。

在同一个生命周期中的命令,执行后面的命令,前面的命令自动执行

三套名称 描述 命令
Clean Lifecycle 在进行真正的构建之前进行一些清理工作。 clean
Default Lifecycle 构建的核心部分，编译，测试，打包，部署等等。 compile,test,package,install,deploy
Site Lifecycle 生成项目报告，站点，发布站点。 site
3.2.1 clean生命周期 clean生命周期的目的是清理项目
阶段 描述
pre-clean 执行一些需要在clean之前完成的工作
clean 移除所有上一次构建生成的文件
post-clean 执行一些需要在clean之后立刻完成的工作
3.2.2 default生命周期
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(部署) 将最终的项目包复制到远程仓库中与其他开发者和项目共享。
3.2.3 site生命周期
site生命周期的目的是建立和发布项目站点，Maven能够基于POM所包含的信息，自动生成一个友好的站点，方便团 队交流和发布项目信息。

阶段 描述
pre-site 执行一些需要在生成站点文档之前完成的工作
site 生成项目的站点文档
post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
site-deploy 将生成的站点文档部署到特定的服务器上
3.3 Maven概念模型
Maven 包含了一个项目对象模型 (POM:Project Object Model)，一组标准集合，一个项目生命周期(Project Lifecycle)，一个依赖管理系统(Dependency Management System)，和用来运行定义在生命周期阶段(phase)中插 件(plugin)目标(goal)的逻辑。

项目对象模型 (Project Object Model)

一个maven工程都有一个pom.xml文件，通过pom.xml文件定义项目的坐标、项目依赖、项目信息、插件目标等。

依赖管理系统(Dependency Management System)

通过maven的依赖管理对项目所依赖的jar 包进行统一管理。比如:项目依赖junit4.12，通过在pom.xml中定义 junit4.12的依赖即使用junit4.12，如下所示是junit4.12的依赖定义:

1
2
3
4
5
6
7
8

    <scope>test</scope>
</dependency>

使用maven完成项目的构建，项目构建包括:清理、编译、测试、部署等过程，maven将这些过程规范为一个生命

周期

清理 ➡ 编译 ➡ 测试 ➡ 报告 ➡ 打包 ➡ 部署
一组标准集合

maven将整个项目管理过程定义一组标准。

比如:通过maven构建工程有标准的目录结构，有标准的生命周期阶 段、依赖管理有标准的坐标定义等。

插件(plugin)目标(goal)

maven 管理项目生命周期过程都是基于插件完成的。

四.IDEA创建Maven工程
4.1 IDEA配置本地Maven
进入configure–>settings–>build–>build tools–>Maven中，设置maven工具和本地仓库

进入configure–>settings–>build–>build tools–>Maven–>Runner中，设置VM Options:-DarchetypeCatalog=internal -Dfile.encoding=GB2312

4.2 IDEA创建工程
Java工程

选择Maven，下一步，设置GroupID域名倒写，ArtifactID项目名，Version版本号

手动创建test测试配置文件目录

test目录右击创建resources目录，然后Mark Directory AS选Resources Root

指定maven环境的jdk版本和字符集

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

打开右侧maven栏，双击命令即可

如何导入依赖

1
2
3
4
5
6
7
8
9
10
11
12

点击项目，选择插件功能JBLJavaToWeb即可将Java项目转换为Web项目

4.3 发布web工程
idea使用外置tomcat运行

Add Configurations–>ADD=>Tomcat(Local)，设置名称Tomcat，其他跟之前项目一样

idea使用maven内置tomcat插件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25




org.apache.maven.plugins
maven-compiler-plugin
3.1

1.8
1.8
UTF-8



org.apache.tomcat.maven
tomcat7-maven-plugin
2.2

8080
/
utf-8




4.4 依赖管理
我们不考虑依赖范围引起的问题

依赖范围 对于编译classpath有效 对于测试classpath有效 对于运行时classpath有效 例子
compile（默认） Y Y Y mybatis
test - Y - junit
provided Y Y - servlet-api
runtime - Y Y JDBC驱动
system Y Y - 本地，maven仓库之外的库
依赖范围 描述
compile 默认依赖范围，作用域在编译、测试、运行时都有效。
test 作用域在测试时有效。编译和运行时不需要，比如：Junit。
provided 作用域在编译、测试时有效。运行时不需要，比如： servlet api 被 tomcat 容器提供。
runtime 作用域在测试、运行时有效。编译时不需要，比如：jdbc的驱动包。
system system范围依赖与provided类似，jar包在本地磁盘而不是maven仓库
在maven_web工程中测试scope:

默认引入 的jar包

compile 【默认范围 可以不写】(编译、测试、运行 都有效 )

servlet-api 、jsp-api

provided (编译、测试 有效， 运行时无效 防止和tomcat下jar冲突)

jdbc驱动jar包

runtime (测试、运行 有效 )

junit

test (测试有效)

依赖范围由强到弱的顺序是:compile>provided>runtime>test

总结

介绍

项目管理工具

• 依赖管理

​ - 通过maven管理jar包的整个过程

• 一键构建

​ - 通过一个maven的一个命令就可以完成工程整个构建的过程

安装和使用

下载和安装

• 下载 3.5.2 版本

• 安装解压到非中文路径

• 配置MAVEN_HOME环境变量

​ - 依赖java环境

仓库分类

本地仓库

远程仓库

• 1.中央仓库

• 2.第三方远程仓库

​ - 阿里云镜像

• 3.私服

配置指定本地仓库

• 帅哥提供5G

​ - 不建议覆盖

配置阿里云镜像

• 提高下载速度

命令和插件

1）clean

• 清理target目录

2）compile

• 编译 src/main/java

3）test

• 测试 src/test/java

4）package

• 将工程进行打包

​ - jar

​ - war

5）install

• 将打包后的工程安装到本地仓库

6）deploy

• 将本地仓库的jar包或war包上传到私服

生命周期

清理生命周期

• clean

默认生命周期

• compile

​ - test

​ - package

​ - install

​ - deploy

站点生命周期

• site

IDEA配置maven工具

全局settings配置

• 指定maven工具路径

• 指定maven工具配置文件路径

• 指定maven工具本地仓库的路径

指定本地创建maven时，使用本地骨架

• -DarchetypeCatalog=internal -Dfile.encoding=GB2312

IDEA创建maven工程

1)创建java工程

2）创建web工程

• 下载JBLJavaToWeb插件

IDEA发布web工程

1）使用本地tomcat

2）使用tomcat插件

• pom.xml

依赖范围

1）我们编写的web工程需要手动导入servlet-api 坐标

2）在打成 war包的时候将servlet-api 设置到 /WEB-INF/lib目录下

3）如果与tomcat软件内置的版本不一致，可能会启动报错

4）需要指定jar包的作用范围（provided）

有哪些依赖范围呢？

• compile

​ - 默认，在编译、测试、运行期有效

• test

​ - 仅在测试期有效

• provided

​ - 在编译、测试期有效

• runtime

​ - 在测试、运行期有效

• system

​ - 从本地中导入jar包

一.JDBC基础
1.1 概述
Java 数据库连接(Java DataBase Connectivity)

作用:通过Java语言操作数据库

本质:是官方(sun公司)定义的一套操作所有关系型数据库的规则(接口)。各个数据库厂商去实现这套接口，提 供数据库驱动jar包。我们可以使用这套接口(JDBC)编程，运行时的代码其实是驱动jar包中的实现类。

1.2 快速入门
需求

通过java代码向数据库user表插入一条记录

准备数据库和表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
CREATE DATABASE Day48;
USE Day48;
CREATE TABLE USER
(
id INT PRIMARY KEY AUTO_INCREMENT,
username VARCHAR(50),
password VARCHAR(50)
);
INSERT INTO USER (username, password)
VALUES (‘admin’, ‘123’),
(‘tom’, ‘123’),
(‘jack’, ‘123’);

SELECT * FROM USER;
创建java工程，导入MySQL驱动jar包

mysql-connector-java-5.1.45-bin.jar

编写插入代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class JDBCDEMO {
public static void main(String[] args) throws Exception {
//1.注册驱动
// DriverManager.registerDriver(new Driver());
Class.forName(“com.mysql.jdbc.Driver”);
//2.建立连接
Connection connection = DriverManager.getConnection(“jdbc:mysql://localhost:3306/Day48”, “root”, “root”);
//3.编写sql
String sql = “insert into user values(4,’lucy’,666)”;
//4.获取sql执行对象
Statement statement = connection.createStatement();
//5.执行sql并返回结果
int i = statement.executeUpdate(sql);
//6.处理结果
if (i > 0) {
System.out.println(“Success”);
} else {
System.out.println(“Failed”);
}
//7.释放资源
statement.close();
connection.close();
}
}
1.3 API介绍
sun公司提供的:java.sql包下

DriverManager:驱动管理对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
1.注册驱动
1)static void registerDriver(Driver driver)
我们通过翻看MySQL Driver实现类的源码发现内部的静态代码已经提供了注册驱动功能
static {
try{
DriverManager.registerDriver(new Driver());
}catch(SQLException var1){
throw new RuntimeException(“Can’t register driver!”);
}
}
2)反射
Class.forName(“com.mysql.jdbc.Driver”);
3)SPI 服务提供接口 【Service Provider Interface】
2.建立连接
static Connection getConnection(String url,String user,String password)
参数说明:
url:连接指定数据库地址【固定格式】
格式:jdbc:mysql://ip地址+端口/数据库名
实例:
jdbc:mysql://localhost:3306/day23
jdbc:mysql:///day23
user:用户名
password:密码
Connection:数据库连接对象

1
2
3
4
5
6
7
8
9
10
11
12
13

1. 获取sql执行对象【小货车】
   Statement createStatement()
   PreparedStatement prepareStatement(String sql)
2. 事务管理
   1)关闭自动提交(开启事务)
   void setAutoCommit(boolean autoCommit)
   参数:
   true:自动提交【默认值】
   false:手动提交
   2)提交事务
   void commit()
   3)回滚事务
   void rollback()

Statement:执行sql的对象

1
2
3
4
5
6
7
8
9
10

1. 执行所有类型sql语句【了解】
   boolean execute(String sql)
2. 仅执行DML类型sql语句
   int executeUpdate(String sql)
   参数:dml类型sql(insert、update、delete)
   返回值:影响行数
3. 仅执行DQL类型sql语句
   ResultSet executeQuery(String sql)
   参数:dql类型sql(select)
   返回值:结果集
   ResultSet:结果集对象,封装查询结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1. 指针下移
   boolean next()
   返回值:
   true:表示此行有数据
   false:表示此行没有数据
   while(resultSet.next){
   //获取一行数据
   }

2. 获取数据
   根据制定列编号和数据类型获取
   T getXxx(int 列编号)
   根据指定列名和数据类型获取
   T getXxx(String 列名)

   补充:获取所有类型
   Object getObject(String 列名)
   String getString(String 列名)

1.4 CRUD操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// 1.注册驱动
// 2.建立连接
// 3.编写sql
// 4.获取sql执行对象 // 5.执行sql并返回结果 // 6.处理结果
// 7.释放资源

public class CRUDDEMO {
//新增
@Test
public void testInsert() throws Exception {
Class.forName(“com.mysql.jdbc.Driver”);
Connection connection = DriverManager.getConnection(“jdbc:mysql://localhost:3306/Day48”, “root”, “root”);
String sql = “insert into user values(NULL,’testInsert’,666)”;
Statement statement = connection.createStatement();
int i = statement.executeUpdate(sql);
if (i > 0) {
System.out.println(“Successful”);
} else {
System.out.println(“Failed”);
}
statement.close();
connection.close();
}

//修改
@Test
public void testUpdate() throws Exception {
    Class.forName("com.mysql.jdbc.Driver");
    Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/Day48", "root", "root");
    String sql = "UPDATE user SET username='testUpdate' WHERE id = 4";
    Statement statement = connection.createStatement();
    int i = statement.executeUpdate(sql);
    if (i > 0) {
        System.out.println("Successful");
    } else {
        System.out.println("Failed");
    }
    statement.close();
    connection.close();
}

//删除
@Test
public void testAlter() throws Exception {
    Class.forName("com.mysql.jdbc.Driver");
    Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/Day48", "root", "root");
    String sql = "delete from user WHERE id = 2";
    Statement statement = connection.createStatement();
    int i = statement.executeUpdate(sql);
    if (i > 0) {
        System.out.println("Successful");
    } else {
        System.out.println("Failed");
    }
    statement.close();
    connection.close();
}

//查询
@Test
public void testFindAll() throws Exception {
    Class.forName("com.mysql.jdbc.Driver");
    Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/Day48", "root", "root");
    String sql = "SELECT * FROM user";
    Statement statement = connection.createStatement();
    ResultSet resultSet = statement.executeQuery(sql);

    while (resultSet.next()) {
        int id = resultSet.getInt("id");
        String username = resultSet.getString("username");
        String password = resultSet.getString("password");
        System.out.println("\tID:" + id + "\tUSERNAME:" + username + "\tPASSWORD:" + password);
    }
    resultSet.close();
    statement.close();
    connection.close();
}

}
1.5 工具类
通过上面案例需求我们会发现每次去执行SQL语句都需要注册驱动，获取连接，得到Statement，以及释放资源。发

现很多重复的劳动，我们可以将重复的代码定义到一个工具类中。

目的:简化书写，一劳永逸

步骤分析

1
2
3
4
5
6
7
8
9
10
11
public class JdbcUtils{
// 1.注册驱动【保证一次】
static{ }
// 2.提供获取连接的静态方法
public static Connection getConnection(){
return null;
}
// 3.提供释放资源的方法
public void close(){
}
}
1.5.1 版本一
该版本具有耦合性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class JdbcUtils1 {
// 1.注册驱动【保证一次】
static {
try {
Class.forName(“com.mysql.jdbc.Driver”);
} catch (ClassNotFoundException e) {
throw new RuntimeException(“Load JDBC Driver Failed”);
}
}

// 2.提供获取连接的静态方法
public static Connection getConnection() throws SQLException {
    return DriverManager.getConnection("jdbc:mysql://localhost:3306/Day48", "root", "root");
}

// 3.提供释放资源的方法
public void close(ResultSet resultSet, Statement statement, Connection connection) {
    if (resultSet != null) {
        try {
            resultSet.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (statement != null) {
        try {
            statement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (connection != null) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

// 重载关闭方法
public static void close(Statement statement, Connection connection) {
    close(statement, connection);
}

}

1.5.2 版本二
解耦合版本

1
2
3
4
5
#K-V
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/Day48
jdbc.user=root
jdbc.password=root
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public class JdbcUitls {

// 声明变量
private static String driver = null;
private static String url = null;
private static String user = null;
private static String password = null;

// 加载jdbc.properties配置文件，初始化变量
static {
    ResourceBundle jdbc = ResourceBundle.getBundle("jdbc");
    driver = jdbc.getString("jdbc.driver");
    url = jdbc.getString("jdbc.url");
    user = jdbc.getString("jdbc.user");
    password = jdbc.getString("jdbc.password");
}

// 1.注册驱动【保证一次】
static {
    try {
        Class.forName(driver);
    } catch (ClassNotFoundException e) {
        throw new RuntimeException("Load Driver Failed");
    }
}

// 2.提供获取连接的静态方法
public static Connection getConnection() throws Exception {
    return DriverManager.getConnection(url, user, password);
}

// 3.提供释放资源的方法
public static void close(ResultSet resultSet, Statement statement, Connection connection) {
    if (resultSet != null) {
        try {
            resultSet.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (statement != null) {
        try {
            statement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (connection != null) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

// 重载关闭方法
public static void close(Statement statement, Connection connection) {
    close(null, statement, connection);
}

}

1.6 事务操作
事务

如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败

MySQL事务操作

事务
开启事务 begin | start transaction;
提交事务 commit;
回顾事务 rollback;
Java操作(使用Connection对象)

事务
关闭自动提交(开启事务) void setAutoCommit(false);
提交事务 void commit();
回顾事务 void rollback();
需求:

通过Java代码实现转账案例

导入账户表

1
2
3
4
5
6
7
CREATE TABLE account(
id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(10),
money DOUBLE
);
INSERT INTO account(name,money) VALUES (‘UserA’,1000),(‘UserB’,1000);

编写转账代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class TXDemo{
@Test
public void testTX(){
try{
// 1.获取连接【JdbcUtils工具类】
// 2.开启事务
// 3.UserA扣钱
// 机器故障
// 4.UserB加钱
// 5.提交事务
}catch(Exception e){
// 6.回滚事务
}finally{
// 7.释放资源
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class TXDemo {
@Test
public void testTX() {
Connection connection = null;
Statement statement = null;
try {
// 1.获取连接【JdbcUtils工具类】
connection = JdbcUitls.getConnection();
// 2.开启事务
connection.setAutoCommit(false);
tatement = connection.createStatement();
// 3.UserA扣钱
// 机器故障
// 4.UserB加钱
// 5.提交事务
connection.commit();
} catch (Exception e) {
try {
// 6.回滚事务
connection.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
} finally {
// 7.释放资源
JdbcUitls.close(statement, connection);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public class TXDemo {
@Test
public void testTX() {
Connection connection = null;
Statement statement = null;
try {
// 1.获取连接【JdbcUtils工具类】
connection = JdbcUitls.getConnection();
// 2.开启事务
connection.setAutoCommit(false);
statement = connection.createStatement();

        // 3.UserA扣钱
        String ASql = "update account set money = money-100 where id=2;";
        int AResult = statement.executeUpdate(ASql);
        if (AResult > 0) {
            System.out.println("User A Payment Successful");
        }
        // 机器故障
        int a = 1 / 0;
        String BSql = "update account set money = money +100 where id =1;";
        // 4.UserB收到钱
        int BResult = statement.executeUpdate(BSql);
        if (BResult > 0) {
            System.out.println("User B Get the Payment");
        }
        // 5.提交事务
        connection.commit();
    } catch (Exception e) {
        e.printStackTrace();
        try {
            // 6.回滚事务
            connection.rollback();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    } finally {
        // 7.释放资源
        JdbcUitls.close(statement, connection);
    }
}

}
二.案例:用户登陆
2.1 需求分析
浏览器登录
⬇
服务器LoginServlet
接收用户请求
用户名，密码
⬇
操作JDBC
根据用户名和密码查询数据库 ➡
⬅ Server
⬇
判断用户是否登录成功
⬇正确 ➡错误 转发登录页面提示
重定向至list.jsp
2.2 代码实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package com.test.web;

import com.test.util.JdbcUitls;

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.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

@WebServlet(“/LoginServlet”)
public class LoginServlet 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 {
    //统一编码
    req.setCharacterEncoding("utf-8");
    resp.setContentType("text/html;charset=utf-8");
    //接收请求
    String username = req.getParameter("username");
    String password = req.getParameter("password");

    try {
        // 2.操作JDBC
        // 2.1 获取连接
        Connection connection = JdbcUitls.getConnection();

        // 2.2 编写sql
        // String sql = "select * from user where username ='admin' and password='123'";
        String sql = "SELECT * FROM user WHERE username='" + username + "'AND password ='" + password + "'";
        System.out.println(sql);

        // 2.3 获取sql执行对象
        Statement statement = connection.createStatement();

        // 2.4 执行sql并返回结果
        ResultSet resultSet = statement.executeQuery(sql);

        // 3.判断是否登录成功
        if (resultSet.next()) {// 成功
            String loginUsername = resultSet.getString("username");
            req.getSession().setAttribute("loginUsername", loginUsername);
            resp.sendRedirect(req.getContextPath() + "/list.jsp");
        } else {// 失败
            req.setAttribute("error", "Username/Password Wrong");
            req.getRequestDispatcher("/login.jsp").forward(req, resp);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

}

}

总结

jdbc

概述

• 通过java语言操作数据库

本质

• 面向接口编程思想

• sun公司通过操作关系型数据库的一套规范（接口），所有的数据库厂商都需要实现这套接口，对于开发者只需要学习这套接口的API就可以操作所有类型的关系型数据库，真正的执行者是实现类（jar包驱动）

快速入门

• 1.注册驱动

• 2.建立连接

• 3.编写sql

• 4.获取sql执行对象

• 5.执行sql并返回结果

• 6.处理结果

• 7.释放资源

API详解

• DriverManager

​ - 1.注册驱动

​ - Class.forName()

​ - 2.建立连接

• Connection

​ - 1.获取sql执行对象

​ - Statement

​ - PreparedStatement

​ - 2.事务安全

• Statement

​ - 1.仅执行DML类型sql语句

​ - int executeUpdate(String sql)

​ - 2.仅执行DQL类型sql语句

​ - ResultSet executeQuery(String sql)

• ResultSet

​ - 1.指针下移

​ - boolean next()

​ - 2.获取数据

​ - T getXxx(String 列名)

crud练习

• 新增

• 修改

• 删除

• 查询所有

JdbcUtils

• 版本一

• 版本二

事务安全

• 模拟转账

一.Listener
1.1 概述
Java Web 中的监听器(观察者模式)，监视特定对象并在其状态发生变化时触发相应处理。

监听器三大对象：HttpServletRequest, HttpSession, ServletContext

一.概述
Web中的过滤器:当用户访问服务器资源时，过滤器将请求拦截，完成一些通用操作

应用场景:登陆验证，统一编码处理，敏感字符过滤

Docker安装使用Oracle 11g

拉取镜像

1
2
3
4
5
6
7
8
9
10
11

# 拉取镜像
docker pull registry.cn-hangzhou.aliyuncs.com/helowin/oracle_11g
# 可以改名
docker tag xxxxxxxxxx oracle:oracle_11g  

# 启动镜像
docker run -d -p 1521:1521 --name oracle_11g oracle_11g:latest               
# 查看容器是否运行
docker ps -a

配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 进入容器
docker exec -it oracle_11g bash  

# 切换到root
su root
#密码:helowin

# 编辑profile文件
vi /etc/profile

# 最后行添加如下环境变量
export ORACLE_HOME=/home/oracle/app/oracle/product/11.2.0/dbhome_2
export ORACLE_SID=helowin
export PATH=$ORACLE_HOME/bin:$PATH

# 创建软链接
ln -s $ORACLE_HOME/bin/sqlplus /usr/bin

# 切换回oracle
su - oracle

一.JSP
1.1 概述
简单来说:在html标签中嵌套java代码
作用:简化书写，展示动态页面

一.EL
1.1 概述
表达式语言(Expression Language)
作用:
主要用于代替jsp中脚本的功能，简化对java代码对操作
语法:
${表达式}