Jsp应用实训一

分层开发

• 表现层
• 业务逻辑层
• 数据访问层
• 数据库

后台功能

• 分类管理

  • 分类的id
  • 分类的名称

• 商品管理

  • 商品的id
  • 商品的名称
  • 商品的价格
  • 商品描述

准备工作

• 软件

  • IntellJ Idea 2017~2020版本都可以
  • MySQL5.5~5.7 都可以{5.7的版本完全区分表的名称大小写}
  • Jdk1.8 （示例开发:1.8.211）
  • Tomcat（9.0）
  • Maven3.63

• 创建Maven项目 命名store

• 选择到maven

  • Maven home directory：apache-maven-3.6.3
  • User setting file：apache-maven-3.6.3\conf\settings.xml

• 关于Maven的设置

  在maven的目录下有一个文件夹叫conf（配置的目录）内有一个文件名称是 settings.xml 进行修改

  • 修改 坐标的下载位置[若不修改、需确定有D盘、且下方路径存在]
    • <localRepository>D:\Tols\Repository</localRepository>
  • 修改 jar下载源采用为阿里镜像

• 程序的目录结构如下

  • src
    ----main
    -------java
    -------webapp
    ----test
    -------java
    ----pom.xml
    store.iml
    

• 编写pom.xml

  • <?xml version="1.0" encoding="UTF-8"?>
    
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
    
      <groupId>StoreMall</groupId>
      <artifactId>StoreMall</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
    
      <name>StoreMall Maven Webapp</name>
      <!-- FIXME change it to the project's website -->
      <url>http://www.example.com</url>
    
      <properties>
          <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
      </properties>
    
        <dependencies>
            <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
            <!--数据驱动包-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
            <!--选择【阿里巴巴的德鲁伊】数据源-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.14</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/commons-dbutils/commons-dbutils -->
            <!--导入工具类：1.dbutils -->
            <dependency>
                <groupId>commons-dbutils</groupId>
                <artifactId>commons-dbutils</artifactId>
                <version>1.6</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
            <!--导入工具类：2.beanutil -->
            <dependency>
                <groupId>commons-beanutils</groupId>
                <artifactId>commons-beanutils</artifactId>
                <version>1.9.3</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
            <!--导入工具类：3.lang3 -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>3.8.1</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
            <!--依赖包： 日志包-->
            <dependency>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
                <version>1.2</version>
            </dependency>
    
    
    
            <!--    导入servlet坐标-->
            <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>4.0.1</version>
                <scope>provided</scope>
            </dependency>
            <!--    导入jsp坐标-->
            <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
            <dependency>
                <groupId>javax.servlet.jsp</groupId>
                <artifactId>javax.servlet.jsp-api</artifactId>
                <version>2.3.3</version>
                <scope>provided</scope>
            </dependency>
            <!-- 导入Jstl标准标签库的坐标-->
            <dependency>
                <groupId>org.apache.taglibs</groupId>
                <artifactId>taglibs-standard-spec</artifactId>
                <version>1.2.5</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.taglibs</groupId>
                <artifactId>taglibs-standard-impl</artifactId>
                <version>1.2.5</version>
            </dependency>
            <!--单元测试-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.11</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
        <build>
            <finalName>storemall</finalName>
            <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
                <plugins>
                    <plugin>
                        <artifactId>maven-clean-plugin</artifactId>
                        <version>3.1.0</version>
                    </plugin>
                    <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                    <plugin>
                        <artifactId>maven-resources-plugin</artifactId>
                        <version>3.0.2</version>
                    </plugin>
                    <plugin>
                        <artifactId>maven-compiler-plugin</artifactId>
                        <version>3.8.0</version>
                    </plugin>
                    <plugin>
                        <artifactId>maven-surefire-plugin</artifactId>
                        <version>2.22.1</version>
                    </plugin>
                    <plugin>
                        <artifactId>maven-war-plugin</artifactId>
                        <version>3.2.2</version>
                    </plugin>
                    <plugin>
                        <artifactId>maven-install-plugin</artifactId>
                        <version>2.5.2</version>
                    </plugin>
                    <plugin>
                        <artifactId>maven-deploy-plugin</artifactId>
                        <version>2.8.2</version>
                    </plugin>
                </plugins>
            </pluginManagement>
        </build>
    </project>
    
    

• 配置文件- db.properties

  • driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/store
    classname=root
    password=root
    

---

编写代码

• 创建各个包

  • 实体包 entity
  • 服务层(业务逻辑层)接口包 dao
  • 服务层(业务逻辑层)接口的实现类包 daoimpl
  • 持久层(数据访问层)接口包 service
  • 持久层(数据访问层)接口的实现类包 serviceimpl
  • 工具包 util
  • 异常包 exception
  • 通用包 commons
  • 数据库包
  • Servlet包
  • fifilter包
  • [测试包] test

• 类目的实体类

  • Category

    package cn.javabs.store.entity;
    
    /**
     * 类别
     * getter和setter方法
     * toString方法
     * 构造方法
     *      有参构造方法
     *      无参构造方法
     */
    public class Category {
        private Integer cid;
        private String cname;
    
        @Override
        public String toString() {
            return "Category{" +
                    "cid=" + cid +
                    ", cname='" + cname + '\'' +
                    '}';
        }
    
        public Category(Integer cid, String cname) {
            this.cid = cid; this.cname = cname;}
    
        public Category() {super();}
    
        public Integer getCid() {return cid;}
    
        public void setCid(Integer cid) {this.cid = cid;}
    
        public String getCname() {return cname;}
    
        public void setCname(String cname) {this.cname = cname;}
    }
    

• 类目的Service的接口

  • CategoryService

    package cn.javabs.store.service;
    
    import cn.javabs.store.entity.Category;
    import java.util.List;
    
    /** 类目的功能逻辑 
      * 思考？ 类目会涉及到分页功能吗？ | 不涉及到！ 
      */
    public interface CategoryService {
        /**
         * 查询全部类目
         */
        public List<Category> findAllCategries();
        /**
         * 指定查找类目
         */
        public Category findCategoryById(Integer id);
        /**
         * 添加类目
         */
        public int addCategory(Category category);
        /**
         * 修改类目
         */
        public int editCategory(Category category);
        /**
         * 删除类目
         */
        public int delCategory(Integer id);
    
    }
    

• 类目的Service的接口的实现类ServiceImpl

  • CategoryServiceImpl

    package cn.javabs.store.service.impl;
    
    import cn.javabs.store.dao.CategoryDao;
    import cn.javabs.store.dao.impl.CategoryDaoImpl;
    import cn.javabs.store.entity.Category;
    import cn.javabs.store.service.CategoryService;
    
    import java.util.List;
    
    /**
     * 业务逻辑层实现类
     */
    public class CategoryServiceImpl implements CategoryService {
        // 创建Dao 层对象 进行此类中进行 dao类的方法
    
        CategoryDao categoryDao = new CategoryDaoImpl();
    
        /**
         * 查询所有类目
         */
        @Override
        public List<Category> findAllCategries() {
            List<Category> categoryList = categoryDao.findAll();
            return categoryList;
        }
    
        /**
         * 指定查询类目
         */
        @Override
        public Category findCategoryById(Integer id) {
            Category category =  categoryDao.findById(id);
            return category;
        }
    
        /**
         * 添加类目
         */
        @Override
        public int addCategory(Category category) {
            int number = categoryDao.add(category);
            return number;
        }
    
        /**
         * 修改类目
         */
        @Override
        public int editCategory(Category category) {
            int number = categoryDao.update(category);
            return number;
        }
    
        /**
         * 删除类目
         */
        @Override
        public int delCategory(Integer id) {
            int number = categoryDao.delById(id);
            return number;
        }
    }
    

• 类目的dao的接口

  • CategoryDao

    package cn.javabs.store.dao;
    
    import cn.javabs.store.entity.Category;
    
    import java.util.List;
    
    public interface CategoryDao {
        /**
         * 查询所有类目
         */
        List<Category> findAll();
    
        /**
         * 指定查询
         */
        Category findById(Integer id);
    
        /**
         * 添加类目
         */
        int add(Category category);
    
        /**
         * 修改类目
         */
        int update(Category category);
    
        /**
         * 删除类目
         */
        int delById(Integer id);
    }
    

• 类目的dao的接口的实现类DaoImpl

  • CategoryDaoImpl

    package cn.javabs.store.dao.impl;
    
    import cn.javabs.store.dao.CategoryDao;
    import cn.javabs.store.entity.Category;
    import cn.javabs.store.util.DruidUtil;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    import org.apache.commons.dbutils.handlers.BeanListHandler;
    
    import java.sql.SQLException;
    import java.util.List;
    
    public class CategoryDaoImpl implements CategoryDao {
        /**
         * 准备QueryRunner
         * 因为QueryRunner的有参数构造方法需要一个参数的 参数为DataSource类型的ds
         * 而DruidUtil.getDs() 方法是一个 返回
         */
        QueryRunner qr = new QueryRunner(DruidUtil.getDataSource());
    
        /**
         * 查询所有类目
         */
        @Override
        public List<Category> findAll() {
            try {
                List<Category> list = qr.query("select cid,cname from category",new BeanListHandler<Category>(Category.class));
                return list;
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        /**
         * 指定查询类目
         */
        @Override
        public Category findById(Integer id) {
    
            try {
                 Category category = qr.query("select cid,cname from category where cid=?",
                        new BeanHandler<Category>(Category.class));
                return category;
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        /**
         * 添加类目
         */
        @Override
        public int add(Category category) {
            try {
                int num = qr.update("insert into category(cid,cname) values(?,?)",
                        null,category.getCname());
                return num;
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
    
        }
        /**
         * 修改类目
         */
        @Override
        public int update(Category category) {
            try {
                int num = qr.update("update category set cname=? where cid=?",
                        category.getCname(),
                        category.getCid());
                return num;
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        /**
         * 删除类目
         */
        @Override
        public int delById(Integer id) {
            try {
                int num = qr.update("delete from category where cid=?",id);
                return num;
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
    
        }
    }
    

• 工具类的创建 DruidUtil

  • DruidUtil

    package cn.javabs.store.util;
    
    import com.alibaba.druid.pool.DruidDataSourceFactory;
    
    import javax.sql.DataSource;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.Properties;
    
    /**
     * 工具类
     */
    public class DruidUtil {
        // 1.定义全局变量ds  类型是 DataSource（数据源）
        private static DataSource dataSource;
        // 2.定义静态代码块
        static {
            try {
                // 2.1 通过反射读取 db.properties文件 返回一个io对象
                InputStream is = DruidUtil.class.getClassLoader().getResourceAsStream("db.properties");
                // 2.2 找properties类去读取（加载）io流
                // 2.2.1 创建properties对象
                Properties properties = new Properties();
                // 2.2.2 读取
                properties.load(is);
                // 2.3 通过核心类[德鲁伊数据源工厂]去创建数据源 会返回一个DataSource类型 --会有一场需要try
                DruidDataSourceFactory.createDataSource(properties);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        // 3.定义静态方法：获取数据源  返回值类为 DataSource
        public static DataSource getDataSource(){
            //3.1 返回ds
            return dataSource;
        }
        // 4.定义静态方法：获取连接方法 返回值类为 Connection
        public static Connection getConnection() throws SQLException {
            //4.1 返回调用获取连接 -- 会有异常
            return dataSource.getConnection();
        }
    }
    
    

• 数据库表结构搭建

  • # 创建数据库 
    create database store; 
    # 选择哪1个数据库来进行操作 
    use store; 
    create table category( 
        cid int primary key auto_increment, 
        cname varchar(50) not null unique # not null 不许为空、| unique 唯一的约束 
    );
    # 插入语句 
    insert into category(cid,cname) values (1,'手机'); 
    insert into category(cid,cname) values (2,'手机壳'); 
    insert into category(cid,cname) values (3,'充电器');
    
    

• 单元测试

  • package cn.javabs.store.test;
    
    import cn.javabs.store.entity.Category;
    import cn.javabs.store.service.CategoryService;
    import cn.javabs.store.service.impl.CategoryServiceImpl;
    import org.junit.Test;
    
    import java.util.List;
    
    public class TestCategory {
        //创建对象CategoryService
        CategoryService categoryService = new CategoryServiceImpl();
        /**
         * 查询所有类目
         */
        @Test
        public void testFindAllCategories(){
            List<Category> list = categoryService.findAllCategries();
            System.out.println("从数据库中查询到的分类和类目有："+list);
        }
    
        /**
         * 根据id进行指定查询
         */
        @Test
        public void testFindById(){
            Category category = categoryService.findCategoryById(2);
            System.out.println(category);
        }
    
        /**
         * 添加分类
         */
        @Test
        public void testAddCategory(){
            Category category = new Category(null,"耳机");
            // 这是用 有参数的构 造方法
            int number = categoryService.addCategory(category);
            System.out.println("数据库插入了"+number+"条语句"); }
    
        /**
         *  修改分类
         */
        @Test
        public void testEditCategory(){
            Category category = new Category(2,"手机保护壳");
            int number = categoryService.editCategory(category);
            System.out.println("数据库修改了"+number+"条语句"); }
    
        /**
         * 删除分类
         */
        @Test
        public void testDelCategoryById(){
            int number = categoryService.delCategory(4);
            System.out.println("数据库删除了"+number+"条语句");
        }
    }