笔记-JavaWeb学习之旅5

CP30的演示

package cn.itcast.datasourcejdbc;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
public class C3P0Demo2 {
    public static void main(String[] args){
        //创建连接池对象，使用多态
        //不指定配置文件的名称，会连接默认配置
        DataSource ds = new ComboPooledDataSource();
        //使用getConnection方法获取连接
        try{
            //归还连接对象演示
            //文件默认配置了10个连接
            for(int i = 0 ; i <10 ; i++){
                Connection c = ds.getConnection();
                //i<5个的话不会报错
                //i<11的话会报异常 An attempt by a client to checkout a Connection has timed out.
                System.out.println(i+""+c);
                //现在归连接
                if(i==5){
                    c.close();
                    //运行正常，并且控制台打印的对象有两个地址是一样的
                }
            }
        }catch(SQLException e){
            e.printStackTrace();
        }
    }
}

Druid

package cn.itcast.druid;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;
public class DruidDemo1 {
    public static void main(String[] args) throws Exception{
        //druid包下的类DruidDataSourceFactory有个方法可以获取到连接池对象
        // DruidDataSourceFactory需要Properties参数
        //创建Properties对象
        Properties p = new Properties();
        //加载读取文件配置,需要一个参数字节输入流或字符输入流
        //获取字节输入流参数，可以先获取字节码文件然后通过方法getClassLoader来获取ClassLoader对象
        //通过ClassLoader对象来获取字节输入流
       Class aClass=new DruidDemo1().getClass();
       ClassLoader aClassClassLoader= aClass.getClassLoader();
       InputStream aInputStream = aClassClassLoader.getResourceAsStream("druid.properties");
        //有了字节输入流对应的资源，就可以让他加载了
        //以上代码都可以通过一行代码来实现
        //InputStream aInputStream = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
        p.load(aInputStream);
        //获得数据库连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(p);
        //创建连接
        Connection aConnection = ds.getConnection();
        System.out.println(aConnection);
    }
}

Druid工具类的创建

package cn.itcast.utils;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class JDBCUtils {
    //定义成员变量DataSource
    private static DataSource ds;
    static{
        try {
            //加载配置文件
            Properties pro = new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            //获取连接池
           ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //获取连接方法
    public static Connection getConnection() throws SQLException {
            return ds.getConnection();
    }
    //释放资源方法
    public static void close(Statement stmt, Connection conn){
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public static void close(ResultSet rs,Statement stmt, Connection conn){
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    //获取连接池方法
    public static DataSource getDataSouce(){
        return ds;
    }
}

package cn.itcast.druid;
import cn.itcast.utils.JDBCUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class DruidDemo2 {
    public static void main(String[] args) {
        Connection c =null;
        PreparedStatement ps =null;
        //使用Druid操作数据库
        try {
            //获取连接
            c = JDBCUtils.getConnection();
            //要执行sql语句，需要先创建sql语句,sql语句的参数使用？占位符
            String sql = "INSERT INTO emp(id,ename,salary)VALUES(?,?,?)";
            //要执行sql语句，需要创建prepareStatement对象
            //prepareStatement对象可以通过Connection对象的方法来获取
             ps = c.prepareStatement(sql);
            //调用prepareStatement的方法给占位符赋值
            ps.setInt(1,10015);
            ps.setString(2,"李白");
            ps.setDouble(3,15000.00);
            //执行sql语句
            int count = ps.executeUpdate();
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.close(ps,c);
        }
    }
}

package cn.itcast.jdbcTemplate;
import cn.itcast.utils.JDBCUtils;
import org.springframework.jdbc.core.JdbcTemplate;
public class JDBCTemplateDemo {
    public static void main(String[] args) {
        //创建JDBCTemplate对象
        //参数给予数据源，让他连接到数据库
        JdbcTemplate jt = new JdbcTemplate(JDBCUtils.getDataSouce());
        //定义sql语句
        String sql = "UPDATE emp set salary = ? where id = ?";
       //调用update方法，参数一个是sql语句，另一个给占位符赋值
        //赋值与问好占位符一一对应
        int count = jt.update(sql,20000.00,10015);
        System.out.println(count);
    }
}

Spring JDBC

Spring框架对JDBC的简单封装，提供了一个JDBCTemplate对象简化JDBC的开发

步骤：

1. 导入jar包
2. 创建jdbcTemplate对象。依赖于数据源DataSource
3. 调用jdbcTemplate的方法来完成crud的操作
   1. update():执行DML语句，增删改语句
   2. queryForMap():查询结果将结果集封装为map集合
   3. queryForList();查询结果将结果集封装为list集合
   4. query():查询结果，将结果封装为JavaBeanduixang
   5. queryForObject:查询结果封装为对象

package cn.itcast.test;
import cn.itcast.utils.JDBCUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
public class Demo {
    private JdbcTemplate jt = new JdbcTemplate(JDBCUtils.getDataSouce());
    //单元测试，可以让方法独立执行
    @Test
    //修改1001号数据salary为15000
    public void test1(){
        //创建框架对象，参数传递数据源
        //创建sql语句
        String sql = "Update emp set salary = 15000 where id = ?";
        //有了框架，不用创建prepareStatement对象也可以执行sql语句了
        int count = jt.update(sql,1001);
        System.out.println(count);
    }
    //添加一条记录
    @Test
    public void test2(){
        String sql = "insert into emp(id,ename,salary) values (?,?,?)";
        int count= jt.update(sql,1016,"郭靖",12000);
        System.out.println(count);
    }
    //删除刚刚添加的记录
    @Test
    public void test(){
        String sql = "delete from emp where id = ?";
        int count = jt.update(sql,1016);
        System.out.println(count);
    }
    //查询id为1001的记录，将其封装为Map集合
    @Test
    public void test4(){
        String sql = "select * from emp where id = ?";
        //查询的结果集长度只能是1，如果要查询两行的数据的话，会报错
        Map<String,Object> map = jt.queryForMap(sql,1001);
        System.out.println(map);
        //{id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=15000.00, bonus=null, dept_id=20}
    }
    @Test
    //查询所有记录，将其封装为List集合
    public void test5(){
    String sql = "select * from emp";
    //queryForList方法会把每一天记录封装为map集合，然后再将map集合封装为List集合
    List<Map<String,Object>> list = jt.queryForList(sql);
    for(Map<String,Object> map : list){
        System.out.println(map);
    }
    }
    @Test
    //查询所有记录，将其封装成Emp对象的list集合
    public void test6(){
        String sql = "select * from emp";
        //query方法有两个参数，一个是sql语句，一个是RowMapper的实现类，一般我们使用它给我们提供的实现类，BeanPropertyRowMapper,这个实现类可以完成数据到JavaBean的自动封装
        List<Emp> list = jt.query(sql,new BeanPropertyRowMapper<Emp>(Emp.class));
        for(Emp emp :list){
            System.out.println(emp);
        }
    }
    @Test
    //查询总记录数
    public void test7(){
        String sql = "select count(id) from emp";
        //第一个参数是sql，第二个参数是class类型，是一个将来要返回的Class类型
        //将来要返回Long类型，那么参数就是Long.class
        Long l = jt.queryForObject(sql,Long.class);
        System.out.println(l);
    }
}

Web概念概述

JavaWeb:使用Java语言开发基于互联网的项目

软件架构：

1. C/S:Client/Server 客户端/服务器端

   在用户本地有一个客户端程序，在远程有一个服务器端程序

   如QQ,迅雷....

   优点：1.用户体验号

   缺点：开发，安装，部署，维护麻烦

2. B/S：Browser/Server 浏览器/服务器端

   只需要一个浏览器，用户通过不同的网址(URL),客户访问不同的服务器端程序

   优点：1.开发，安装，部署，维护，简单

   缺点：如果应用过大，用户体验可能会受影响

   ​ 对硬件要求过高

B/S架构详解

资源分类：

1.静态资源：使用静态网页开发技术发布的资源，特点：所有用户访问，得到结果是一样的，比如，文本，图片，视频，HTML,CSS,JavaScript。如果用户请求的是静态资源，那么服务器会直接将静态资源放送给浏览器。浏览器中内置了静态资源的解析引擎，可以展示静态资源

2.动态资源：使用动态网页及时发布的资源，特点所有用户访问，得到的结果可能不一样，如:JSP/servlet，php，asp....。如果用户请求的是动态资源，那么服务器就会执行动态资源，转换为静态资源，在发送给浏览器

我们要学习动态资源你，就必须先学习静态资源

静态资源(三剑客):

HTML:用于搭建基础网页，展示网页的内容

CSS:用于美化页面，布局页面

JavaScript:控制页面的元素，让页面有一些动态的效果

HTML快速入门

语法：

1. html文档后缀名.html 或者.htm
2. 标签分为
   1. 围堵标签：有开始标签和结束标签如
   2. 自闭和标签:开始标签和结束标签在一起
3. 标签可以嵌套：
4. 在开始标签中可以定义属性。属性是由键值对构成，值需要用引号引起来
5. html的标签不区分大小写，但是建议小写。

<html>
	<head>
		<title>title</title>
	</head>
	<body>
		<font color='red'>Hello World</font><br/>
		<font color='green'>Hello World</font>
	</body>
</html>

3.标签学习

1. 文件标签：构成html最基本的标签

   1. html:html文档的根标签
   2. head：头标签。用于指定html文档的一些属性。引入外部资源
   3. title:标题标签
   4. body：体标签
   5. （）: html5中定义该文档是html文档

2. 文本标签：和文本有关的标签

   1. 注释：

   2. .
      

      to
      

      :标题标签

   3. .

      :段落标签

   4. 换行标签

   5. 展示水平线
      

      ---

      ；拥有属性可以改变水平线的样式color：颜色，width：宽度，size：高度，align：对齐方式(center:居中对齐，left：左对齐，right：右对齐)

   6. 字体加粗：

   7. 字体斜体

   8. 字体标签有颜色(color)，大小(size)，字体样式的属性(face)

      属性定义：

      1. color

         1. 英文单词：red,green,blue
         2. rge(值1，值2 ，值3)，值得范围0~255,如 rgb(0,0,255),表示红色绿色为0，蓝色为255

         width：

         1. 数值：width='20'，数值的单位，默认是px(像素)
         2. 数值%:占比相对于父元素的比列

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>文本标签</title>
</head>
<body>
    <!-- 注释 -->
    <!-- br 换行-->
    <!--h1~h6标题标签-->
    云想衣裳花想容<br>
    春风扶槛露华浓<br>
    若非群玉山头见<br>
    会向瑶台月下逢<br>
    <!-- 段落标签 p-->
    <p>
    黄河远上白云间
    <p/>
    <p>
    一片孤城万仞山
    <p/>
    <p>
    羌笛何须怨杨柳
    <p/>
    <p>
    春风不度玉门关
    </p>
    <!--hr显示一条水平线 是自闭和标签-->
    <hr color = 'red'/>
    <!--加粗b-->
    春风不度玉门关<br>
    <b>春风不度玉门关</b>
    <!--斜体i-->
    <i>羌笛何须怨杨柳</i>
    <hr>
    <!--字体font-->
    <font color="red" size ="5" face="楷体">云想衣裳花想容</font><br>
</body>
</html>

1. 图片标签：
   1. src:指定图片的位置

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>图片标签</title>
</head>
<body>
    <!--alt 代表找不到图片的话就用指定的文字代替-->
    <img src="3.jpg" width="500" align="right" alt="图片挂了">
</body>
</html>

1. 列表标签：

   ​ 有序列表:ol ， li代表每一项

   ​ 无序列表ul ，li代表每一项

   <!DOCTYPE html>
   <html lang="en">
   <head>
       <meta charset="UTF-8">
       <title>Title</title>
   </head>
   <body>
       <!--有序列表ol-->
       早上起床干的事情
       <ol>
           <li>睁眼</li>
           <li>看手机</li>
           <li>洗衣服</li>
           <li>洗漱</li>
       </ol>
       <!--有无列表ul-->
       <ul>
           <li>睁眼</li>
           <li>看手机</li>
           <li>洗衣服</li>
           <li>洗漱</li>
       </ul>
   </body>
   </html>
   

2. 链接标签：

   a:定义以超链接

   ​ 属性：href：指定访问资源的URL(统一资源定位符)

   ​ target :指定打开资源的方式

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>链接标签</title>
</head>
<body>
    <!--超链接a-->
    <a href="https://www.cnblogs.com/train99999/">点击在本页面进入我的博客</a><br>
    <!--点击在新的页面打开选项卡-->
    <a href="https://www.cnblogs.com/train99999/" target="_blank">点击在新的选项卡中打开</a><br>
    <!--访问本地的资源-->
    <a href="3.jpg">点击加载本地图片</a><br>
    <!--打开会打开本地邮箱-->
    <a href="mailto:123456@train.com">点击联系我</a>
    <!--点击图片加载链接-->
    <a href="https://www.cnblogs.com/train99999/"><img src="3.jpg"></a>
</body>
</html>

div和span：

div：每一个div占满一整行，块级标签

span：文本信息在一行展示，行内标签，内联标签

语义化标签：html5中为了提高程序的可读性，提供了一些标签(header,footer)这些标签对页面没有任何的样式。