idea服务器接口给Android idea连接服务器

文章目录

• 1、常见的数据库连接池

• 数据库连接池引入
• DBCP连接池
• C3P0连接池
• Driud连接池

• 2、DBUtils工具类的用法
• 3、IDEA与数据库的连接
• 4、Web应用

• WEB开发的相关知识
• WEB应用程序
• 静态WEB
• 动态WEB

• 5、了解tomcat服务器

• WEB服务器简介
• tomcat服务器详解

• 6、将Java项目发布在服务器上的三种方式

• 将项目在webapps目录下
• 配置server.xml文件
• 新建XML文件进行配置

• 7、IDEA中发布Web项目
• 8、HTTP协议
• 9、请求与响应
• 10、Servlet快速入门

1、常见的数据库连接池

数据库连接池引入

• 最原始的数据库使用就是 打开一个连接并进行使用，使用过后一定要关闭连接释放资源。由于频繁的打开和关闭连接对JVM包括数据库都有一定的资源负荷，尤其应用压力较大时资源占用比较多容易产生性能问题。
• 由此使用连接池的作用就显现出来，它的原理其实不复杂：先打开一定数量的数据库连接，当使用的时候分配给调用者，调用完毕后返回给连接池，注意返回给连接池后这些连接并不会关闭，而是准备给下一个调用者进行分配。由此可以看出连接池节省了大量的数据库连接打开和关闭的动作，对系统性能提升的益处不言而喻。
• 几个概念：

最小连接————应用启动后随即打开的连接数以及后续最小维持的连接数。
最大连接数————应用能够使用的最多的连接数
连接增长数————应用每次新打开的连接个数

• 举个例子说明连接池的运作：

假设设置了最小和最大的连接为10，20，那么应用一旦启动则首先打开10个数据库连接，但注意此时数据库连接池的正在使用数字为0–因为你并没有使用这些连接，而空闲的数量则是10。然后你开始登录，假设登录代码使用了一个连接进行查询，那么此时数据库连接池的正在使用数字为1、空闲数为9，这并不需要从数据库打开连接–因为连接池已经准备好了10个给你留着呢。登录结束了，当前连接池的连接数量是多少？当然是0，因为那个连接随着事务的结束已经返还给连接池了。然后同时有11个人在同一秒进行登录，会发生什么：连接池从数据库新申请（打开）了一个连接，连同另外的10个一并送出，这个瞬间连接池的使用数是11个，不过没关系正常情况下过一会儿又会变成0。如果同时有21个人登录呢？那第21个人就只能等前面的某个人登录完毕后释放连接给他。这时连接池开启了20个数据库连接–虽然很可能正在使用数量的已经降为0，那么20个连接会一直保持吗？当然不，连接池会在一定时间内关闭一定量的连接还给数据库，在这个例子里数字是20-10=10，因为只需要保持最小连接数就好了，而这个时间周期也是连接池里配置的。

• 市面上常见的数据库连接池有以下几种：

DBCP连接池

• DBCP（DataBase Connection Pool）数据库连接池，是Java数据库连接池的一种，由Apache开发，通过数据库连接池，可以让程序自动管理数据库连接的释放和断开；
• 使用步骤:

1.导入jar包(commons-dbcp-1.4.jar和commons-pool-1.5.6.jar)，产生依赖；
2.使用API：a.硬编码(不推荐) b.配置文件的方式

• 硬编码方式：

import org.apache.commons.dbcp.BasicDataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MyTest {
    public static void main(String[] args) throws SQLException {
        //创建连接池对象
        BasicDataSource ds = new BasicDataSource();
        //配置信息
        ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/shop?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC&useSSL=false");
        ds.setUsername("root");
        ds.setPassword("123456");
        //获取连接对象
        Connection conn = ds.getConnection();
        String sql = "select * from user where upwd=?";
        //获取预编译的操作对象
        PreparedStatement statement = conn.prepareStatement(sql);
        //设置参数
        statement.setString(1, "123456");
        //获取结果集对象
        ResultSet resultSet = statement.executeQuery();
        while (resultSet.next()) {
            int id = resultSet.getInt(1);
            String username = resultSet.getString(2);
            String password = resultSet.getString(3);
            System.out.println("用户的id是：" + id + "，用户名是：" + username + "，密码是：" + password);
        }
        //使用连接池之后，可以不用手动的销毁连接对象，连接池已经帮你做了

        /*用户的id是：1，用户名是：zhangsan，密码是：123456
        用户的id是：2，用户名是：lisi，密码是：123456
        用户的id是：3，用户名是：wangwu，密码是：123456
        用户的id是：6，用户名是：zhaoliu，密码是：123456*/
    }
}

使用完连接池之后，不用手动释放资源，连接池本身已经帮你做了；

• 配置文件方式：

import org.apache.commons.dbcp.BasicDataSourceFactory;
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;

public class MyTest1 {
    public static void main(String[] args) throws Exception {
        //读取配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("dbcp.properties"));
        //将配置文件传给静态方法，返回一个数据源对象
        DataSource ds = BasicDataSourceFactory.createDataSource(properties);
        //获取连接对象
        Connection conn = ds.getConnection();
        String sql = "select * from user where upwd=?";
        //获取预编译的操作对象
        PreparedStatement statement = conn.prepareStatement(sql);
        //设置参数
        statement.setString(1, "123456");
        //获取结果集对象
        ResultSet resultSet = statement.executeQuery();
        while (resultSet.next()) {
            int id = resultSet.getInt(1);
            String username = resultSet.getString(2);
            String password = resultSet.getString(3);
            System.out.println("用户的id是：" + id + "，用户名是：" + username + "，密码是：" + password);
        }

        /*用户的id是：1，用户名是：zhangsan，密码是：123456
        用户的id是：2，用户名是：lisi，密码是：123456
        用户的id是：3，用户名是：wangwu，密码是：123456
        用户的id是：6，用户名是：zhaoliu，密码是：123456*/
    }
}

配置文件：

#连接基本设置
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/shop?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC&useSSL=false
username=root
password=123456


#<!--扩展配置 了解-->
#初始化连接
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000

#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;] 
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=gbk

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

在这里很明显可以发现，加载配置文件的路径是自己写的，也就意味着配置文件可以任意的命名，任意的存放它的位置；

C3P0连接池

• C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate、Spring等。
• c3p0与dbcp区别：

dbcp没有自动回收空闲连接的功能；
c3p0有自动回收空闲连接功能

• 使用步骤:

1.导入jar包(c3p0-0.9.1.2.jar)
2.使用API

• 硬编码方式：

import com.mchange.v2.c3p0.ComboPooledDataSource;

import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MyTest2 {
    public static void main(String[] args) throws SQLException, PropertyVetoException {
        //创建连接池对象
        ComboPooledDataSource ds = new ComboPooledDataSource();
        //设置参数
        ds.setDriverClass("com.mysql.cj.jdbc.Driver");
        ds.setUser("root");
        ds.setPassword("123456");
        ds.setJdbcUrl("jdbc:mysql://localhost:3306/shop?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC&useSSL=false");
        //获取连接对象
        Connection conn = ds.getConnection();
        String sql = "select * from user where upwd=?";
        //获取预编译的操作对象
        PreparedStatement statement = conn.prepareStatement(sql);
        //设置参数
        statement.setString(1, "123456");
        //获取结果集对象
        ResultSet resultSet = statement.executeQuery();
        while (resultSet.next()) {
            int id = resultSet.getInt(1);
            String username = resultSet.getString(2);
            String password = resultSet.getString(3);
            System.out.println("用户的id是：" + id + "，用户名是：" + username + "，密码是：" + password);
        }
    }
}

该连接池相对于前者，只导入一个jar包；其余步骤与前者一样，没什么区别；

• 配置XML文件方式：

要求1：配置文件的名称为c3p0-config.xml；
要求2：配置文件的路径为src下

import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MyTest3 {
    public static void main(String[] args) throws SQLException {
        //默认读取配置文件
        ComboPooledDataSource ds = new ComboPooledDataSource();
        Connection conn = ds.getConnection();
        String sql = "select * from user where upwd=?";
        //获取预编译的操作对象
        PreparedStatement statement = conn.prepareStatement(sql);
        //设置参数
        statement.setString(1, "123456");
        //获取结果集对象
        ResultSet resultSet = statement.executeQuery();
        while (resultSet.next()) {
            int id = resultSet.getInt(1);
            String username = resultSet.getString(2);
            String password = resultSet.getString(3);
            System.out.println("用户的id是：" + id + "，用户名是：" + username + "，密码是：" + password);
        }
    }
}

XML配置文件：

<c3p0-config>
	<!-- 默认配置，如果没有指定则使用这个配置 -->
	<default-config>
		<!-- 基本配置 -->
		<property name="driverClass">com.mysql.cj.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://localhost:3306/shop?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true</property>
		<property name="user">root</property>
		<property name="password">123456</property>
	
		<!--扩展配置-->
		<property name="checkoutTimeout">30000</property>
		<property name="idleConnectionTestPeriod">30</property>
		<property name="initialPoolSize">10</property>
		<property name="maxIdleTime">30</property>
		<property name="maxPoolSize">100</property>
		<property name="minPoolSize">10</property>
		<property name="maxStatements">200</property>
	</default-config> 
	
	
	<!-- 命名的配置 -->
	<named-config name="myname">
		<property name="driverClass">com.mysql.cj.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://localhost:3306/librarymansys?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true</property>
		<property name="user">root</property>
		<property name="password">123456</property>
		
		
		<!-- 如果池中数据连接不够时一次增长多少个 -->
		<property name="acquireIncrement">5</property>
		<property name="initialPoolSize">20</property>
		<property name="minPoolSize">10</property>
		<property name="maxPoolSize">40</property>
		<property name="maxStatements">20</property>
		<property name="maxStatementsPerConnection">5</property>
	</named-config>
</c3p0-config>

1、我数据库使用的版本是MySQL 8，MySQL 5的数据库在配置XML文件的时候，URL会有所不同；
2、观察上面的配置文件，发现他还有第二个配置，也就是说还可以连接其他数据库，不仅仅是MySQL数据库，显得很灵活，在创建连接池对象的时候，将这个name属性的值当作参数传递过去；这里，我配置了MySQL的另外一个数据库进行测试：

import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MyTest4 {
    public static void main(String[] args) throws SQLException {
        //获取连接池对象
        ComboPooledDataSource ds = new ComboPooledDataSource("myname");
        //获取连接对象
        Connection conn = ds.getConnection();
        String sql = "select * from admin";
        //获取预编译的操作对象
        PreparedStatement statement = conn.prepareStatement(sql);
        //获取结果集对象
        ResultSet resultSet = statement.executeQuery();
        while (resultSet.next()) {
            int id = resultSet.getInt(1);
            String username = resultSet.getString(2);
            String sex = resultSet.getString(3);
            System.out.println("用户的id是：" + id + "，用户名是：" + username + "，性别是：" + sex);
        }
    }
}

• 配置properties文件方式：

要求1：配置文件的名称为c3p0.properties 要求2：配置文件的路径为src下

import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MyTest5 {
    public static void main(String[] args) throws SQLException {
        //默认读取配置文件
        ComboPooledDataSource ds = new ComboPooledDataSource();
        Connection conn = ds.getConnection();
        String sql = "select * from user where upwd=?";
        //获取预编译的操作对象
        PreparedStatement statement = conn.prepareStatement(sql);
        //设置参数
        statement.setString(1, "123456");
        //获取结果集对象
        ResultSet resultSet = statement.executeQuery();
        while (resultSet.next()) {
            int id = resultSet.getInt(1);
            String username = resultSet.getString(2);
            String password = resultSet.getString(3);
            System.out.println("用户的id是：" + id + "，用户名是：" + username + "，密码是：" + password);
        }
    }
}

配置文件：

c3p0.driverClass=com.mysql.cj.jdbc.Driver
c3p0.jdbcUrl=jdbc:mysql://localhost:3306/shop?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC&useSSL=false
c3p0.user=root
c3p0.password=123456

观察上面两个配置文件方式连接数据库，会发现配置文件名以及文件存放的位置都是固定的，这是因为你没有手动给出文件加载的路径，因此C3P0底层默认帮你读取该文件，所以文件存放的路径和文件名都必须是固定的；

Driud连接池

• DRUID是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、PROXOOL等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池(据说是目前最好的连接池，不知道速度有没有BoneCP快)。

使用步骤，导入德鲁伊的jar包；
使用API；

采用硬编码的方式：.

import com.alibaba.druid.pool.DruidDataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class MyTest6 {
    public static void main(String[] args) throws Exception{
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/shop");
        ds.setUsername("root");
        ds.setPassword("123456");
        //获取连接对象
        Connection conn = ds.getConnection();
        String sql = "select * from user where upwd=?";
        //获取预编译的操作对象
        PreparedStatement statement = conn.prepareStatement(sql);
        //设置参数
        statement.setString(1, "123456");
        //获取结果集对象
        ResultSet resultSet = statement.executeQuery();
        while (resultSet.next()) {
            int id = resultSet.getInt(1);
            String username = resultSet.getString(2);
            String password = resultSet.getString(3);
            System.out.println("用户的id是：" + id + "，用户名是：" + username + "，密码是：" + password);
        }
    }
}

采用配置文件的方式：.

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;

public class MyTest7 {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        properties.load(new FileInputStream("druid.properties"));

        DataSource ds = DruidDataSourceFactory.createDataSource(properties);
        Connection conn = ds.getConnection();

        String sql = "select * from user where upwd=?";
        //获取预编译的操作对象
        PreparedStatement statement = conn.prepareStatement(sql);
        //设置参数
        statement.setString(1, "123456");
        //获取结果集对象
        ResultSet resultSet = statement.executeQuery();
        while (resultSet.next()) {
            int id = resultSet.getInt(1);
            String username = resultSet.getString(2);
            String password = resultSet.getString(3);
            System.out.println("用户的id是：" + id + "，用户名是：" + username + "，密码是：" + password);
        }
    }
}

配置文件：

#基本配置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost/shop
username=root
password=123456
#可选配置
filters=stat
initialSize=2
maxActive=300
maxWait=60000
timeBetweenEvictionRunsMillis=60000
minEvictableIdleTimeMillis=300000
validationQuery=SELECT 1
testWhileIdle=true
testOnBorrow=false
testOnReturn=false
poolPreparedStatements=false
maxPoolPreparedStatementPerConnectionSize=200

配置文件的路径以及文件名都是可以随意写的，因为这里手动加载读取了配置文件，而不是默认加载；

2、DBUtils工具类的用法

• Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。
• 使用步骤:

1.导入jar包(commons-dbutils-1.4.jar)
2.创建一个queryrunner类，queryrunner作用：操作sql语句

构造方法:
new QueryRunner(Datasource ds);

3.编写sql
4.执行sql

query(..):执行r操作 			
update(...):执行cud操作

代码实例：

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.util.List;
import java.util.Properties;

public class MyTest {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        properties.load(new FileInputStream("druid.properties"));
        DataSource ds = DruidDataSourceFactory.createDataSource(properties);

        //创建一个操作对象
        QueryRunner queryRunner = new QueryRunner(ds);
        //定义SQL语句
        String sql = "select * from bank where money<?";

        List<bank> list = queryRunner.query(sql, 2000, new BeanListHandler<bank>(bank.class));
        for (bank bank : list) {
            System.out.println("用户ID为：" + bank.getId() + "，用户名为：" + bank.getUsername() + "，用户存款为：" + bank.getMoney());
        }


        String sql1="update bank set username=? where money=?";
        int i = queryRunner.update(sql1, "tianqi", 2000);
        System.out.println(i);

        /*用户ID为：2，用户名为：lisi，用户存款为：1000
        2*/
    }
}

ResultSetHandler：封装结果集的接口；
将查询结果的每一条记录封装成指定的bean对象，将每一个bean对象放入list中返回

由上面的代码可知，该工具类需要与实体类结合，这样就会将查询语句的结果封装在对象当中，对象存放在集合中，遍历集合就可以取出数据；

执行查询语句返回的是结果集对象，执行增删改语句返回的是受影响的行数；

3、IDEA与数据库的连接

选择全局的数据库连接

选择用到的数据库

对数据库表的操作

新建表以及打开控制台

修改表名、表中的字段名、字段类型以及删除表

修改字段名

管理多个数据库

给字段添加索引、外键以及查看存储过程

4、Web应用

WEB开发的相关知识

• WEB，在英语中web即表示网页的意思，它用于表示Internet主机上供外界访问的资源。Internet上供外界访问的Web资源分为：

静态web资源（如html 页面）：指web页面中供人们浏览的数据始终是不变。
动态web资源：指web页面中供人们浏览的数据是由程序产生的，不同时间点访问web页面看到的内容各不相同。

静态web资源开发技术：Html
常用动态web资源开发技术：JSP/Servlet、ASP、PHP等
在Java中，动态web资源开发技术统称为Javaweb；

WEB应用程序

• WEB应用程序指供浏览器访问的程序，通常也简称为web应用。例如有a.html 、b.html……多个web资源，这多个web资源用于对外提供服务，此时应把这多个web资源放在一个目录中，以组成一个web应用（或web应用程序）；
• 一个web应用由多个静态web资源和动态web资源组成，如：html、css、js文件，Jsp文件、java程序、支持jar包、配置文件等等。
• Web应用开发好后，若想供外界访问，需要把web应用所在目录交给web服务器管理，这个过程称之为虚拟目录的映射；
• Web应用的特点就是无需额外安装客户端，比如我们经常访问的淘宝、京东、网易等这些都是属于Web应用；
• 什么是JavaWeb？就是使用Java语言开发web应用程序；

静态WEB

• *htm、*html，这些是网页的后缀，如果现在在一个服务器上直接读取这些内容，那么意味着是把这些网页的内容通过网络服务器展现给用户；
• 在静态WEB程序中，客户端使用WEB浏览器（IE、FireFox等）经过网络(Network)连接到服务器上，使用HTTP协议发起一个请求（Request），告诉服务器我现在需要得到哪个页面，所有的请求交给WEB服务器，之后WEB服务器根据用户的需要，从文件系统（存放了所有静态页面的磁盘）取出内容。之后通过WEB服务器返回给客户端，客户端接收到内容之后经过浏览器渲染解析，得到显示的效果。

静态WEB中存在以下几个缺点：

1、Web页面中的内容无法动态更新，所有的用户每时每刻看见的内容和最终效果都是一样的。为了可以让静态的WEB的显示更加好看，可以加入了JavaScript以完成一些页面上的显示特效，但是这些特效都是在客户端上借助于浏览器展现给用户的，所以在服务器上本身并没有任何的变化。实现静态WEB客户端动态效果的手段：

JavaScript
VBScript

在实际的开发中JavaScript使用得最多；

2、静态WEB无法连接数据库，无法实现和用户的交互。使用数据库保存数据是现在大多数系统的选择，因为数据库中可以方便地管理数据，增删改查操作可以使用标准的SQL语句完成。

动态WEB

• 所谓的动态不是指页面会动，主要的特性的是：WEB的页面展示效果因时因人而变，而且动态WEB具有交互性，WEB的页面的内容可以动态更新。
• 动态WEB中，程序依然使用客户端和服务端，客户端依然使用浏览器（IE、FireFox等），通过网络(Network)连接到服务器上，使用HTTP协议发起请求（Request），现在的所有请求都先经过一个WEB Server Plugin（服务器插件） 来处理，此插件用于区分是请求的是静态资源(*.htm或者是*.html)还是动态资源。
• 如果WEB Server Plugin发现客户端请求的是静态资源(*.htm或者是*.html)，则将请求直接转交给WEB服务器，之后WEB服务器从文件系统中取出内容，发送回客户端浏览器进行解析执行。
• 如果WEB Server Plugin发现客户端请求的是动态资源（*.jsp、*.asp/*.aspx、*.php），则先将请求转交给WEB Container(WEB容器)，在WEB Container中连接数据库，从数据库中取出数据等一系列操作后动态拼凑页面的展示内容，拼凑页面的展示内容后，把所有的展示内容交给WEB服务器，之后通过WEB服务器将内容发送回客户端浏览器进行解析执行。
• 动态WEB现在的实现手段非常多，较为常见的有以下几种：

Microsoft ASP、ASP.NET
PHP
JAVA Servlet/JSP

5、了解tomcat服务器

WEB服务器简介

1、Web服务器是指驻留于因特网上某种类型计算机的程序，是可以向发出请求的浏览器提供文档的程序。当Web浏览器（客户端）连到服务器上并请求文件时，服务器将处理该请求并将文件反馈到该浏览器上，附带的信息会告诉浏览器如何查看该文件（即文件类型）。

2、服务器是一种被动程序：只有当Internet上运行在其他计算机中的浏览器发出请求时，服务器才会响应。

• 常见的web服务器：

服务器名称————厂商————特点

weblogic————oracle————大型的收费的支持javaee所有规范的服务器

websper————IBM————大型的收费的支持javaee所有规范的服务器

tomcat————apache组织————中小型的免费的支持servlet和jsp规范的服务器

tomcat服务器详解

• 学习web开发，为什么必须要先装一个WEB服务器？在本地计算机上随便创建一个web页面，用户是无法访问到的，但是如果启动tomcat服务器，把web页面放在tomcat服务器中，用户就可以访问了。这说明什么问题？

1、不管什么web资源，想被远程计算机访问，都必须有一个与之对应的网络通信程序，当用户来访问时，这个网络通信程序读取web资源数据，并把数据发送给来访者。
2、WEB服务器就是这样一个程序，它用于完成底层网络通迅。使用这些服务器，We应用的开发者只需要关注web资源怎么编写，而不需要关心资源如何发送到客户端手中，从而极大的减轻了开发者的开发工作量。

• 下载和安装Tomcat服务器

Tomcat官方站点：http://jakarta.apache.org
下载Tomcat安装程序包：http://tomcat.apache.org/
下载:https：//tomcat.apache.org/

1、在下载的时候，有好几种文件，我们选择压缩版：
tar.gz文件是Linux操作系统下的安装版本
exe文件是Windows系统下的安装版本
zip文件是Windows系统下的压缩版本

2、安装时解压apache-tomcat-7.0.52.zip即可；注意：不要解压在中文目录

3、以下是tomcat解压之后的目录：

• 启动与关闭 tomcat：

启动：tomcat/bin目录下，双击startup.bat

关闭：

方式1:点 x
方式2:ctrl+c
方式3:双击 shutdown.bat

• 测试Tomcat服务器

打开浏览器，输入http://localhost:8080/，能显示如下界面代表安装成功。

• tomcat常见问题(配置)

1、启动的时候一闪而过，没有正确配置：JAVA_HOME

顾名思义，JAVA_HOME的含义就是JDK的安装路径，新增系统变量JAVA_HOME，在变量值写JDK的安装路径；

2、端口冲突问题

修改tomcat的端口号，打开tomcat/conf/server.xml，大概70行左右有如下代码:

<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />

修改port后面的值就可以了，注意：1024以下的端口号留给系统用的，8080端口是留给http协议用的，我们可以使用这个端口号；

6、将Java项目发布在服务器上的三种方式

将项目在webapps目录下

• Tomcat中的Webapps目录是Tomcat默认的应用目录，当服务器启动时，会加载所有这个目录下的应用。

情况1：将一个简单的Web静态页面放在WebApps目录下的root文件夹当中：

在浏览器当中输入：http://localhost:8080/index.html

• 也可以将JSP程序目打包成一个war包放在目录下，服务器会自动解开这个war包，并在这个目录下生成同名的文件夹，一个war包就是有特性格式的jar包，它是将一个Web程序的所有内容进行压缩得到。具体如何打包，可以使用许多开发工具的IDE环境，如Eclipse、NetBeans、ant、JBuilder、IDEA等。也可以用cmd命令：

jar -cvf applicationname.war package.*

情况2：将一个Java Web项目打成war包放在WebApps目录下：

• 首先创建一个web项目；
• 然后将该项目打包为war包：

在IDEA中将一个Java Web项目打成war包详解

• 在浏览器中访问web项目的JSP文件；

• 可以看到，在webapps下放入的war包，已经被解压了：
  
  

最终，Java代码都被放在了WEB-INF下的classes文件下，服务器只需要编译后的字节码文件，它不认源文件；

web项目的目录结构:★★★
		myweb(项目名称)   web2.5版本标准的目录结构
			|
			|---- html css js image等目录或者文件
			|
			|---- WEB-INF(特点:通过浏览器直接访问不到 目录)
			|	 	|
			|	 	|--- lib(项目的第三方jar包)
			|	 	|--- classes(存放的是我们自定义的java文件生成的.class文件)
			|	 	|--- web.xml(当前项目的核心配置文件)
			|	 	|

• 访问路径：http://主机:端口号/项目名称/资源路径，例如：我的项目 mywar 资源 mywar有一个index.jsp

http://localhost:8080/mywar/index.jsp

配置server.xml文件

• 我们可以选择将项目放在任意位置，然后配置conf目录下的server.xml文件；

新建XML文件进行配置

• 在conf目录中新建Catalina\localhost目录，在该目录中新建一个xml文件，名字可以随意取，只要和当前文件中的文件名不重复就行了。
• 在Tomca的安装目录 conf/Catalina/localhost下，里面有Tomcat自带的三个应用，随意复制其中的一个XML文件，然后修改docbase指向你自己的应用程序，修改文件名，并修改xml文件的内容为：

<Context path="/hello" docBase="D:/myWork" 
reloadable="false" debug="0"
privileged="true" >
</Context>

• xml的文件名必须和path的名字一致， (注意xml文件名(例如：hello.xml)将作为Context中的path属性值，不管文件里的path属性值如何设置也是无效的)；
• 上面例子的访问路径是http://localhost:8080/hello

7、IDEA中发布Web项目

如何在IDEA中配置Tomcat服务器：

如何在IDEA中建立web项目：

如何在IDEA中发布web项目：

8、HTTP协议

1、HTTP:（HyperText Transfer Protocol，超文本传输协议）超文本传输协议，详细的规定了浏览器和服务器之间进行通信的规则，通过网络传输HTML文档数据的协议；
2、HTTP是一个基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件, 查询结果等）。
3、HTTP协议是一个应用层的协议，由请求和响应构成，一次请求一次响应；

• HTTP协议有这几个特点：

1、是我们B/S 架构采用的协议；
2、HTTP可以传输任意数据类型，比如文本，图片，音频，视频等等；
3、HTTP1.0之前使用的是种短连接的方式，什么是短连接，就是限制每次连接只处理一个请求，服务器处理完成之后，并收到浏览器的应答之后，就会断开连接，这种方式的好处是可以节省传输时间；但是缺点是，我请求了一个HTML文档，这个文档中又包含了其他JS文件、图片文件、CSS文件，每当浏览器遇这样一个Web资源，就会建立一个会话，那这样的话需要消耗资源和时间的；
4、现在我们使用的HTTP1.1的版本使用的是长连接，使用长连接的情况下，当一个网页打开完成后，客户端和服务端之间传输数据时，连接不会关闭，如果客户端再次访问这个服务器上的网页，会继续使用这一条已经建立好的连接。当然，这个连接不会永久保持，服务器中可以设置这个保持连接时间；
5、HTTP协议是一种无状态协议，什么叫协议的状态，就是指下一次传输可以记住本次传输数据的能力，那所谓无状态协议，就是http不会为了下一次连接，而维护本次连接所传输的数据，比如浏览器打开一个网页后，关闭浏览器，然后再次打开浏览器，但是服务器并不知道客户关闭了一次浏览器，所以HTTP是无状态协议，那如果说我们在一个网站中的多个页面间需要共享同一个数据，我们可以通过Cookie和Session来实现；

9、请求与响应

• 所谓请求：就是浏览器往服务器发送数据；请求包括有：

请求行————请求信息的第一行
请求头————从请求信息的第二行开始到请求空行结束
请求空行
请求体————从请求空行往下

• 请求行：GET /HTTPTest/login?username=zhangsan&password=123456 HTTP/1.1

格式:  请求方式 /请求的资源?请求参数 协议/版本

请求方式常见的：get请求与post请求

get：会把请求参数拼接在URL后面，数据大小有限制，get请求没有请求体；
post：请求会将请求参数放到请求体里面，数据大小无限制

请求头:

格式 key:value

常见的请求头：

Accept: text/html,image/*	--告诉服务器当前客户端可以接收的文档的类型。其实这里包含了*/*，就表示什么都可以接收；  大类型/小类型 比如 text/css text/javascript
Accept-Charset: ISO-8859-1	--告诉服务器，客户端提交的表单可能使用的编码类型
Accept-Encoding: gzip		--浏览器发给服务器,声明浏览器支持的编码类型
Accept-Language:zh-cn 		--语言环境
Host: localhost:8080		--访问主机
If-Modified-Since: Tue, 11 Jul 2000 18:23:51 GMT	 --客户端第二次请求此URL时，根据 HTTP 协议的规定，浏览器会向服务器传送 If-Modified-Since 报头，询问该时间之后文件是否有被修改过：后面跟的时间是本地浏览器存储的文件修改时间
Referer: http://www.baidu.com/index.jsp	 --来自哪个页面、防盗链
User-Agent: Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)
Cookie
Connection:Keep-Alive   	--链接状态 长链接
Date: Tue, 11 Jul 2000 18:23:51 GMT	--时间

• 所谓响应，就是服务器往浏览器回写数据；
• 响应分为：

响应行:响应信息第一行
	HTTP/1.1 200 OK   格式: 协议/版本 响应状态码 响应的描述
	
常见的响应状态码
     200 成功响应
     404 请求的资源没有找到
     302 重定向
     500  服务器内部错误
响应头:响应信息第二行到响应空行
响应空行
响应体:响应空行以下

常见的响应头：

Location: http://www.baidu.org/index.jsp 	--跳转方向 302重定向
Server:apache tomcat			--服务器型号
Content-Encoding: gzip 			--数据压缩
Content-Length: 80 			--数据长度
Content-Language: zh-cn 		--语言环境
Content-Type: text/html; charset=GB2312 --告诉浏览器，服务器返回的文本采用什么编码
Last-Modified: Tue, 11 Jul 2000 18:23:51 GMT	在浏览器第一次请求某一个URL时，服务器端的返回状态会是200，内容是你请求的资源，同时有一个Last-Modified的属性标记此文件在服务期端最后被修改的时间，
Refresh: 1;url=http://www.hehe.org		--定时刷新
Content-Disposition: attachment; filename=aaa.zip	--下载
Set-Cookie:SS=Q0=5Lb_nQ; path=/search   让浏览器将数据保存到本地
Expires: -1					--缓存  -1 就是让页面立即过期
Cache-Control: no-cache  --浏览器和缓存服务器都不应该缓存页面信息强制每次请求直接发送给源服务器，而不经过本地缓存版本的校验
Connection: Keep-Alive   			--保持连接 长链接
Date: Tue, 11 Jul 2000 18:23:51 GMT

10、Servlet快速入门

• Servlet：server applet 是运行在服务器端的小程序
• 概念：定义了一个类被浏览器访问的规则，是一个接口。
• 功能：

• 接受请求
• 处理请求
• 作出响应

• 快速入门：

0.创建web项目
1.定义一个Java类，实现Servlet接口
2.重写所有未实现方法 service()方法里面写句话
3.配置Servlet，web/WEB-INF/web.xml 配置Servlet

<!-- 配置Servlet，为了配置Servlet的访问路径 -->
<servlet>
		<servlet-name>demo1</servlet-name>
		<servlet-class>cn.itcast.servlet.ServletDemo1</servlet-class>
</servlet>
  
<servlet-mapping>
	<servlet-name>demo1</servlet-name>
	<!-- 设置访问路径，以/开头  -->
	<url-pattern>/demo</url-pattern>
</servlet-mapping>

4.发布项目
5.访问/demo路径访问该Servlet ，浏览器中：http://127.0.0.1:8080/项目名/web.xml中配置的虚拟路径名

• 原理：服务器通过反射的方式，创建Servlet对象，调用其方法；

配置文件：

<servlet>
    <servlet-name>demo</servlet-name>
    <servlet-class>org.zhangjiani.demo.MyTest</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>demo</servlet-name>
    <url-pattern>/demo</url-pattern>
</servlet-mapping>

自定义类：

import javax.servlet.*;
import java.io.IOException;

public class MyTest implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {

    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        //这是最核心的方法
        System.out.println("请求来了！");
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}