maven后端到前端Web项目开发流程一阶段汇总自用--三层架构包开发

最新推荐文章于 2024-07-23 11:13:35 发布
最新推荐文章于 2024-07-23 11:13:35 发布
阅读量1.6k 收藏 12
点赞数 2
文章标签： java 数据库 mysql jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42423774/article/details/108300451
版权

maven基础开发流程

maven是做项目的基础,很重要,进行一点后端java代码汇总加深记忆，相关的前端代码不汇总，因为不咋会

mavenWeb项目的创建

maven的web项目开发首先创建一个maven项目:
web类型的maven项目创建

maven三层架构包开发

在这里插入图片描述

maven开发也要使用基础的三层架构包开发,使用过后的感觉就是哪里有病找哪里,很好使!
**标准web项目后端使用的是Dao业务访问层、service业务实现层和web层三层架构。**当然，还有如domain层里面放与数据库表对应的javabean；utils工具层里面放工具类，一些加密和抽取辅助类；web项目中controller控制层放在web层下，写servlet进行一些与web有关的操作。

1. Dao层

Dao层是数据层，主要是对数据库或者文本文件等数据的操作层，是对数据库的操作，为业务逻辑层或表示层提供数据。

2.service层

service层主要是对业务进行处理，就是对数据进行操作，一些增删改查，上传下载等数据处理的业务逻辑实现。

3.web层

基于servlet对service层的一些访问进行转发，将业务逻辑的实现传递到页面上去（web层也可以实现业务逻辑处理，不过web层事务是针对那些安全性要求较高的系统来说的，官方不推荐在web写，一般来说业务处理都是在service实现）

4.utils层

Util就是工具，在做项目的时候我们总会遇到一些奇奇怪怪的小功能或者重复的代码需要提取。

5.domain层

domain层就是放与数据库对应的javabean对象的，数据库有啥玩意我domain层也要有。

3.后端各层次内容具体介绍

1.pom.xml环境配置

配置一下需要的maven环境jar包,添加tomcat和page分页插件

<?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>com.dou</groupId>
  <artifactId>webapp</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>webtask</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.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <!--mybatis_-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.3</version>
    </dependency>
    <!--分页插件-->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.1.2</version>
    </dependency>
    <!--mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.46</version>
    </dependency>
    <!--druid数据源-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.20</version>
    </dependency>
    <!--junit-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <!-- servlet3.0 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <!--jsp-->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.3.3</version>
      <scope>provided</scope>
    </dependency>
    <!--bean-utils-->
    <dependency>
      <groupId>commons-beanutils</groupId>
      <artifactId>commons-beanutils</artifactId>
      <version>1.9.4</version>
    </dependency>
    <!--apache工具包-->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.9</version>
    </dependency>
    <!--jstl-->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!--jackson-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
    <!--文件上传-->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.1</version>
    </dependency>
    <!--POI-->
    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi</artifactId>
      <version>4.0.1</version>
    </dependency>
    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi-ooxml</artifactId>
      <version>4.0.1</version>
    </dependency>
    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi-ooxml-schemas</artifactId>
      <version>4.0.1</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <!--tomcat插件-->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

2.resources环境层配置

在这里插入图片描述

  1. 创建一个名为dbc.properties的文件,封装数据库对象
    写javaWeb项目还是首先连接需要的数据库，建立jdbc.properties文件封装数据库对象，例如以我的本地mysql数据库为例：设置ip、用户名、密码
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/web
jdbc.username=root
jdbc.password=root
  1. 然后设置mapperconfig映射文件，创建一个SqlMapConfig文件,配置关联数据库的jdbc.properties文件、关联domain中的实体类和Dao层的连接数据库方法。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--mybatis的主配置文件-->
<configuration>
    <!--定义property的配置-->
    <properties resource="jdbc.properties"></properties>


    <!--配置别名:别名配置是给实体类用的，不能用在dao上-->
    <typeAliases>
        <!--指定实体类所在的包，此时包下所有类都会注册别名，别名就是类名称-->
        <package name="com.dou.domain"></package>
    </typeAliases>

    <!--配置分页插件，plugins标签有出现顺序要求，必须在environments之前，同时要在properties和typeAliases之后 -->
    <plugins>
        <!-- com.github.pagehelper.PageInterceptor -->
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <property name="helperDialect" value="mysql" />
            <property name="reasonable" value="true" />
        </plugin>
    </plugins>

    <!--配置默认环境-->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源信息-->
            <dataSource type="POOLED" >
                <!--配置连接数据库的四个基本信息-->
                <property name="driver" value="${jdbc.driver}"></property>
                <property name="url" value="${jdbc.url}"></property>
                <property name="username" value="${jdbc.username}"></property>
                <property name="password" value="${jdbc.password}"></property>
            </dataSource>
        </environment>
    </environments>


    <!--配置映射配置文件的位置-->
    <mappers>
        <!--指定实体映射配置文件所在的包，指定的是dao接口所在的包-->
        <package name="com.dou.dao"></package>
    </mappers>
    
</configuration>

3.之后还要添加数据库执行语句关联Dao层中的方法
这个文件配置在与后端Dao相同包下，清晰明了，就不在后面添加了，直接在这写出来，然后还有什么需要的操作数据的语句可以在另行添加。
这个要和dao层下的接口方法名相对应
我在com/dao创建一个UserDao接口
所以在resources下也创建一个com/dao/UserDao.xml相对应,这种命名方式方便查询修改

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--在这连接dao层中的UserDao接口-->
<mapper namespace="com.dou.dao.UserDao">
    <!--配置domain中实体类属性和数据库表中列的对应关系-->
    <resultMap id="BaseResultMap" type="com.dou.domain.User">
        <id column="id" jdbcType="DECIMAL" property="id"/>
        <result column="username" jdbcType="VARCHAR" property="username"/>
        <result column="email" jdbcType="VARCHAR" property="email"/>

    </resultMap>

    <!--配置查询的列名公共SQL语句-->
    <sql id="Base_Column_List">
        id, username,email
    </sql>

    <!--配置查询所有，带条件-->
    <select id="findAll" resultMap="BaseResultMap">
        select
        <include refid="Base_Column_List"/>
        from user
    </select>

    <!--配置根据ID查询-->
    <select id="findById" parameterType="java.lang.String" resultMap="BaseResultMap">
        select
        <include refid="Base_Column_List"/>
        from user
        where id = #{id,jdbcType=DECIMAL}
    </select>

    <!--配置根据id删除-->
    <delete id="delete" parameterType="java.lang.String">
        delete from user where id = #{id,jdbcType=DECIMAL}
    </delete>

    <!--配置全字段插入，当某个字段没有值时，插入null-->
    <insert id="save" parameterType="com.dou.domain.User">
        insert into user (id, username,email)
        values (#{id,jdbcType=DECIMAL}, #{userName,jdbcType=VARCHAR},#{email,jdbcType=VARCHAR})
    </insert>

    <!--配置全字段更新，当提供的数据为null时，数据库数据会被更新为null-->
    <update id="update" parameterType="com.dou.domain.User">
        update user
        set  username = #{userName,jdbcType=VARCHAR},
             email = #{email,jdbcType=VARCHAR}
        where id = #{id,jdbcType=DECIMAL}
    </update>

</mapper>

3.domain层

然后去写与数据库列属性相对应的javabean实体类
这个就很好写了,写好对应的对象,然后自动生成get和set方法就行
在domain中创建一个User类

/**
 * 用户Pojo
 */
public class User{

    private int id; //Id  INTEGER
    private String username; //用户姓名
    private String email; //Email地址


    public int getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public User() {
    }

    public User(Integer id, String username, String email) {
        this.id = id;
        this.username = username;
        this.email = email;
    }
}

4.dao层主要代码

就是添加我们使用数据库所进行的什么操作,把方法写进接口中,通过接口进行实现.
在dao层下创建一个UserDao接口

import java.util.List;

public interface UserDao {
int sava(User user);

int delete(User user);

int update(User user);

User findById(String id);

List findAll();
}

5.设置一下工具类utils

在做业务实现的之前,设置一下工具类utils,在utils层下添加factory包,里面创建MapperFactory类和TransactionUtil类,添加抽取出来的配置映射文件的代码和编码转换器代码


public class MapperFactory {

    private static SqlSessionFactory FACTORY;
    private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>();

    static {
        //1.读取MyBatis文件
        try (InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");) {
            //2.创建SqlSessionFactory工厂类创建者对象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //3.使用构建者创建SqlSessionFactory工厂
            FACTORY = builder.build(in);
        } catch (Exception e) {
            //打印异常信息到控制台
            e.printStackTrace();
            //抛出错误提示程序终止执行
            throw new ExceptionInInitializerError("初始化SqlSessionFactory失败!");
        }
    }

    /**
     * 获取SqlSession对象.
     * @return 保留此方法是为了后面对业务层方法增强,利用AOP添加事务.
     */
    public static SqlSession getSqlSession() {
        return FACTORY.openSession(false);
    }

    /**
     * 获取Dao接口的代理实现类
     * @param daoClass dao接口字节码
     * @return
     */
    public static <T> T getMapper(SqlSession sqlSession, Class<T> daoClass) {
        //1.判断传入的SqlSession是否为null.
        if (sqlSession == null) {
            return null;
        }
        //2.不为null,创建代理实现类.
        return sqlSession.getMapper(daoClass);
    }
}



public class TransactionUtil {

    /**
     * 提交事务的静态方法.
     * @param sqlSession
     */
    public static void commit(SqlSession sqlSession){
        if(sqlSession!=null) {
            sqlSession.commit();
        }
    }

    /**
     * 回滚事务的静态方法.
     * @param sqlSession
     */
    public static void rollback(SqlSession sqlSession){
        if(sqlSession!=null) {
            sqlSession.rollback();
        }
    }

    /**
     * 释放SqlSession的静态方法.
     * @param sqlSession
     */
    public static void close(SqlSession sqlSession){
        if(sqlSession!=null) {
            sqlSession.close();
        }
    }
}

2.然后直接在utils层下创建基础抽取出来的代码类BeanUtil

/**
 * 填充表单数据到javabean的工具类
 * @author zhy
 *
 */
public class BeanUtil {
	/**
	 * 封装表单中的数据到javabean中
	 * @param request	表单中的数据
	 * @param clazz		封装到哪个javabean
	 * @return	封装好的javabean对象
	 * 使用的是泛型。泛型必须先声明再使用。声明必须在返回值之前
	 * T指的就是泛型，它可以是任意字符，只是作为一个占位符。
	 * 声明时用什么字符，使用时就得用什么
	 */
	public static <T> T fillBean(HttpServletRequest request,Class<T> clazz){
		//1.定义一个T类型的javabean
		T bean = null;
		try{
			//2.实例化bean对象
			bean = clazz.newInstance();
			//3.使用BeanUtils的方法进行封装
			BeanUtils.populate(bean, request.getParameterMap());
			//4.返回
			return bean;
		}catch(Exception e){
			throw new RuntimeException(e);
		}
	}



	/**
	 * 封装表单中的数据到javabean中,带有日期格式数据
	 * @param request	表单中的数据
	 * @param clazz		封装到哪个javabean
	 * @return	封装好的javabean对象
	 * 使用的是泛型。泛型必须先声明再使用。声明必须在返回值之前
	 * T指的就是泛型，它可以是任意字符，只是作为一个占位符。
	 * 声明时用什么字符，使用时就得用什么
	 */
	public static <T> T fillBean(HttpServletRequest request,Class<T> clazz,String datePattern){
		//1.定义一个T类型的javabean
		T bean = null;
		try{
			//2.实例化bean对象
			bean = clazz.newInstance();
			//3.创建日期转换器对象
			DateConverter converter = new DateConverter();
			converter.setPattern(datePattern);
			//4.设置转换器
			ConvertUtils.register(converter, Date .class);
			//5.使用BeanUtils的方法进行封装
			BeanUtils.populate(bean, request.getParameterMap());
			//6.返回
			return bean;
		}catch(Exception e){
			throw new RuntimeException(e);
		}
	}

	/**
	 * 文件上传的表单填充
	 * @param items	文件上传的表单项
	 * @param clazz	要封装的实体类字节码
	 * @param <T>	泛型
	 * @return		返回封装好的对象
	 */
	public static <T> T fillBean(List<FileItem> items,Class<T> clazz){
		//1.定义一个T类型的javabean
		T bean = null;
		try{
			//2.实例化Bean
			bean = clazz.newInstance();
			//3.遍历文件项集合
			for(FileItem item : items){
				//4.判断是不是文件
				if(item.isFormField()){//表单字段，不是文件
					//5.取出表单中的name属性取值
					String fieldName = item.getFieldName();
					//6.使用UTF-8字符集取出表单数据
					String fieldValue = item.getString("UTF-8");
					//7.创建属性描述器对象
					PropertyDescriptor pd = new PropertyDescriptor(fieldName,clazz);
					//8.获取写方法(setXXX方法）
					Method method = pd.getWriteMethod();
					//9.把数据填充到bean中
					method.invoke(bean,fieldValue);
				}
			}
			//10.返回
			return bean;
		}catch(Exception e){
			throw new RuntimeException(e);
		}
	}

	private void save(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
		//将数据获取到，封装成一个对象
		User user = BeanUtil.fillBean(request,User.class,"yyyy-MM-dd");
		//调用业务层接口save
		UserService companyService = new UserServiceImpl();
		companyService.save(user);
		//跳转回到页面list （以下两种方式都可以）
		//list(request,response);
		response.sendRedirect(request.getContextPath()+"/user?operation=list");
	}
}

6.service层主要代码

service层是业务实现层,主要进行业务逻辑的实现
创建一个UserService接口
public interface UserService {
void save(User user);

void delete(User user);

void  update(User user);

User findById(String id);

List<User> findAll();

PageInfo findAll(int page, int size);

}
然后在service层创建一个serviceImpl包,写接口的具体实现
在serviceImpl下创建类UserServiceImpl

public class UserServiceImpl  implements UserService {


    @Override
    public void save(User user) {
        SqlSession sqlSession=null;
        try {
            //获取sqlsession
            sqlSession = MapperFactory.getSqlSession();
            //获取Dao
            UserDao userDao = MapperFactory.getMapper(sqlSession, UserDao.class);
            //调用Dao层操作
            userDao.sava(user);
            //提交事务
            TransactionUtil.commit(sqlSession);
        } catch (Exception e) {
            TransactionUtil.rollback(sqlSession);
            throw new RuntimeException(e);
        }finally {
            try {
                TransactionUtil.close(sqlSession);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }

    @Override
    public void delete(User user) {
        SqlSession sqlSession=null;
        try {
            //获取sqlsession
            sqlSession = MapperFactory.getSqlSession();
            //获取Dao
            UserDao userDao = MapperFactory.getMapper(sqlSession, UserDao.class);
            //调用Dao层操作
            userDao.delete(user);
            //提交事务
            TransactionUtil.commit(sqlSession);

        }catch (Exception e){
            TransactionUtil.rollback(sqlSession);
            throw new RuntimeException(e);
        }finally {
            try {
                TransactionUtil.close(sqlSession);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    @Override
    public void update(User user) {
        SqlSession sqlSession = null;
        try{
            //1.获取SqlSession
            sqlSession = MapperFactory.getSqlSession();
            //2.获取Dao
            UserDao userDao = MapperFactory.getMapper(sqlSession,UserDao.class);
            //3.调用Dao层操作
            userDao.update(user);
            //4.提交事务
            TransactionUtil.commit(sqlSession);
        }catch (Exception e){
            TransactionUtil.rollback(sqlSession);
            throw new RuntimeException(e);
            //记录日志
        }finally {
            try {
                TransactionUtil.close(sqlSession);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    @Override
    public User findById(String id) {
        SqlSession sqlSession = null;
        try{
            //1.获取SqlSession
            sqlSession = MapperFactory.getSqlSession();
            //2.获取Dao
            UserDao userDao= MapperFactory.getMapper(sqlSession,UserDao.class);
            //3.调用Dao层操作
            return userDao.findById(id);
        }catch (Exception e){
            throw new RuntimeException(e);
            //记录日志
        }finally {
            try {
                TransactionUtil.close(sqlSession);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    @Override
    public List<User> findAll() {
        SqlSession sqlSession = null;
        try{
            //1.获取SqlSession
            sqlSession = MapperFactory.getSqlSession();
            //2.获取Dao
            UserDao userDao = MapperFactory.getMapper(sqlSession,UserDao.class);
            //3.调用Dao层操作
            return userDao.findAll();
        }catch (Exception e){
            throw new RuntimeException(e);
            //记录日志
        }finally {
            try {
                TransactionUtil.close(sqlSession);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    @Override
    public PageInfo findAll(int page, int size) {
        SqlSession sqlSession = null;
        try{
            //1.获取SqlSession
            sqlSession = MapperFactory.getSqlSession();
            //2.获取Dao
            UserDao userDao = MapperFactory.getMapper(sqlSession,UserDao.class);
            //3.调用Dao层操作
            PageHelper.startPage(page,size);
            List<User> all = userDao.findAll();
            PageInfo pageInfo = new PageInfo(all);
            return pageInfo;
        }catch (Exception e){
            throw new RuntimeException(e);
            //记录日志
        }finally {
            try {
                TransactionUtil.close(sqlSession);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

7.web层具体代码

具体实现写好了,就可以通过web层中的控制层controller层写链接前端的代码
在web包下创建基础BaseServlet,抽取出service包下接口和类放进去,继承HttpServlet,这样UserServlet直接继承BaseServlet就行

public class BaseServlet extends HttpServlet {
   protected UserService userService;

    @Override
    public void init() throws ServletException {
        userService = new UserServiceImpl();
    }
}

在web/controller包下创建UserServlet类
通过接收不同参数获取进行获取页面跳转.而且根据不同参数获取业务实现层得到的数据库信息,通过 request.setAttribute()添加进域对象中,在html页面中然后获取并展现或者进行修改

@WebServlet("/user")
public class UserServlet extends BaseServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String operation = request.getParameter("operation");
        if("list".equals(operation)){
            this.list(request, response);
        }else if("toAdd".equals(operation)){
            this.toAdd(request,response);
        }else if("save".equals(operation)){
            this.save(request, response);
        }else if("toEdit".equals(operation)){
            this.toEdit(request,response);
        }else if("edit".equals(operation)){
            this.edit(request,response);
        }else if("delete".equals(operation)){
            this.delete(request,response);
        }
    }

    private void list(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
        //进入列表页
        //获取数据
        int page = 1;
        int size = 2;
        if(StringUtils.isNotBlank(request.getParameter("page"))){
            page = Integer.parseInt(request.getParameter("page"));
        }
        if(StringUtils.isNotBlank(request.getParameter("size"))){
            size = Integer.parseInt(request.getParameter("size"));
        }
        PageInfo all = userService.findAll(page, size);
        //将数据保存到指定的位置
        request.setAttribute("page",all);
        //跳转页面
        request.getRequestDispatcher("/WEB-INF/pages/User_list.jsp").forward(request,response);
        /*request.getRequestDispatcher("/WEB-INF/pages/User_List.jsp").forward(request,response);*/
    }

    private void toAdd(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
        //加载所有的部门信息放入到userList
        List<User> all = userService.findAll();
        request.setAttribute("userList",all);
        //跳转页面
        request.getRequestDispatcher("/WEB-INF/pages/User_Add.jsp").forward(request,response);
    }

    private void save(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
        //将数据获取到，封装成一个对象
        User user = BeanUtil.fillBean(request,User.class,"yyyy-MM-dd");
        //调用业务层接口save
//        userService userService = new userServiceImpl();
        userService.save(user);
        //跳转回到页面list
        //list(request,response);
        response.sendRedirect(request.getContextPath()+"/user?operation=findAll");
    }

    private void toEdit(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //查询要修改的数据findById
        String id = request.getParameter("id");
        //        userService userService = new userServiceImpl();
        User user = userService.findById(id);
        //加载所有的部门信息放入到userList
        List<User> all = userService.findAll();
        request.setAttribute("userList",all);
        //将数据加载到指定区域，供页面获取
        request.setAttribute("user",user);
        //跳转页面
        request.getRequestDispatcher("/WEB-INF/pages/User_Update.jsp").forward(request,response);
    }

    private void edit(HttpServletRequest request, HttpServletResponse response) throws IOException {
        //将数据获取到，封装成一个对象
        User user = BeanUtil.fillBean(request,User.class,"yyyy-MM-dd");
        //调用业务层接口save
//        userService userService = new userServiceImpl();
        userService.update(user);
        //跳转回到页面list
        //list(request,response);
        response.sendRedirect(request.getContextPath()+"/user?operation=list");
    }

    private void delete(HttpServletRequest request, HttpServletResponse response) throws IOException {
        //将数据获取到，封装成一个对象
        User user = BeanUtil.fillBean(request,User.class);
        //调用业务层接口save
//        userService userService = new userServiceImpl();
        userService.delete(user);
        //跳转回到页面list
        //list(request,response);
        response.sendRedirect(request.getContextPath()+"/user?operation=list");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request,response);
    }
}

这样后端就完成了,由于有些代码逻辑没完成,里面有些小错误,再改改就好了,后端基础架构就是这样就完成了.

4.前端代码

闲着蛋疼可以下载改写,反正没写完,又是提高业务水平的机会

基础又简洁,还能看,反正不是我写的
在这里插入图片描述

webapp下面放网页设置
WEB-INF下面放网页
index.jsp是动态索引页面,启动时候就启动这个界面

1.webapp下面放网页设置

把css包格式设置、fonts包什么设置、js包动态页面设置放进webapp下面，可以自己设置，如果会的话。

2.WEB-INF下面放网页

在common中放入分页设计page
然后外面的分别是:
添加数据add
查看数据list
修改数据update
这里在前端显示数据主要是遍历后端放入域中的数据,比如一个域中的page数据
<c:forEach items="${page.list}" var=“user”>

                        <tr>
                            <td><input type="checkbox" name="id" value="${user.id }"/></td>
                            <td>${user.id }</td>
                            <td>${user.username}</td>
                            <td>${user.email}</td>
                        </tr>
                    </c:forEach>

遍历一下就可以在设计的表格中显示了

page分页数据就直接在页面下方设置一个div,连接page.jsp,在页面下面就会显示分页数据了.就这样:

<div class="box-footer">
                <jsp:include page="./common/page.jsp">
                    <jsp:param value="${ctx}/user?operation=list" name="pageUrl"/>
                </jsp:include>
            </div>

3.index.jsp索引界面

在这里设置进行页面跳转,点击按钮查看数据库信息,传入后端web层参数,然后后端将数据通过业务实现层获取存入域中,跳转进指定界面,前端再获取数据.进行修改上传下载文件一样一样的.
这里就进行了查看数据库文件的跳转,空少慢慢实现吧.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>跳转页</title>
    <link href="./css/bootstrap.min.css" rel="stylesheet">
    <script src="js/jquery-3.2.1.min.js"></script>
    <script src="js/bootstrap.min.js"></script>
</head>
<body>
<div align="center">
    <a class="btn btn-default" href="/user?operation=list">查看所有用户列表</a>
    <a class="btn btn-default" href="/user?operation=toAdd">添加</a>
</div>
</body>
</html>

里面web.xml里面说让设置放行静态资源,不敢感觉没啥用啊

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
  <!-- 放行静态资源[否则无法加载静态资源] -->
  <servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.js</url-pattern>
    <url-pattern>*.css</url-pattern>
    <url-pattern>/assets/*"</url-pattern>
    <url-pattern>/images/*</url-pattern>
    <url-pattern>*.map</url-pattern>
  </servlet-mapping>
</web-app>

5.完结,设计模式就这样的

可能,大概,也许,真的就是这样的吧

6.完整文件下载

在这里插入图片描述
maven简单项目

java冲啊
关注
2-1. Maven 三层项目结构搭建
天罡gg的专栏
03-15 5344
通过上文：1-3. 开发环境安装（全），我们完成了开发环境的安装！ 本文开始第二章：二、项目结构搭建 正所谓：万丈高楼平地起，打好地基是关键！ 主要内容：创建Maven项目、三层架构说明、搭建三层架构、常见问题解决方法 。该遇到的问题我都提前想到了，很多小细节，等你收割！ 通过本文，我希望你能清楚的回答以下问题： 如何创建干净的Maven项目？建议如何定义Maven坐标? 如何搭建三层架构？各层职责如何划分? Maven如何统一定义依赖包版本? dependencyManagement是什么？有什么作用
后端开发-WebIDE的后端程序-基于Maven构建.zip
04-02
本资源“后端开发-WebIDE的后端程序-基于Maven构建.zip”聚焦于利用Maven这一强大的构建工具来搭建和管理Java后端项目，特别适合Web集成开发环境（WebIDE）的开发工作。 1. **Java后端开发**：Java是一种广泛使用的...
maven系列（二）MVC三层架构
liuxiaofan_的博客
08-13 2536
一.MVC简介   MVC模式（Model-View-Controller）是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。 控制器Controller：对请求进行处理，负责请求转发；Servlet 视图View：界面设计人员进行图形界面设计；JSP 模型Model：程序编写程序应用的功能（实现算法等等）、数...
Maven教程超详细
最新发布
小钟不想敲代码
07-23 1049
Maven教程超详细
完整 maven项目 SSM整合步骤（先前端、后后端）
qq_49214533的博客
10-24 1502
maven项目 SSM整合步骤（先前端、后后端） 首先创建一个maven项目在pom.mxl中添加war这样项目就能达成war包了。 在main新建webapp，如果pom.xml中不加war，webapp文件夹的颜色是不一样的，只有像我这样才行，然后创建WEB-INF，web.xml 整合ssm项目前先把需要的jar包全部导入 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/P
Maven下构建三层架构
m0_54034052的博客
12-28 694
—基模块,就是常说的parent(pom)——数据库的访问层，例如jdbc操作(java)——项⽬的业务逻辑层(java)——⽤来接收请求，响应数据(web)
npm与Maven：前端与后端构建工具深度对比学习
球球不吃虾WHR2349博客
03-06 2506
本篇博客旨在通过对npm和Maven这两个在各自领域具有重大影响力的构建工具进行全面且深入的对比分析，帮助前端开发者理解如何有效利用npm来优化前端项目构建与依赖管理，同时让Java开发者了解Maven的核心价值及其实现机制。我们将从基础概念、核心功能、实际应用场景等多个维度展开讨论，揭示两者在依赖管理策略、构建流程设计、社区支持等方面的异同点，以便开发者能够在不同场景下灵活运用相应的工具，提高开发效率和项目质量。通过此番比较学习，我们期望能促进跨领域的知识交流，推动开发实践的创新与进步。
JAXRS-Jersey:Jersey Maven Eclipse 动态 Web 项目，遵循 JAX-RS 规范，具有 mysql 数据库后端和基于 angular-js 的前端
07-02
总的来说，这个项目提供了一个全面的实例，展示了如何使用Java、JAX-RS、Jersey、Maven、MySQL和AngularJS来构建一个功能完整的Web服务，涵盖了从后端数据处理到前端用户交互的完整流程。对于学习和理解RESTful服务...
SpringBoot项目博客系统-包含前台后台前端后端-适合作为Java学习的第一练手项目.zip
03-09
总结起来，这个项目涵盖了Java Web开发的核心技术，包括SpringBoot、Maven构建、数据库操作、前端页面和后端服务的交互，以及版本控制和项目组织。对于想要学习Java和SpringBoot的开发者来说，这是一个绝佳的实践...
物流快递系统前、后端+Java语言+SpringBoot项目+MVC三层架构+maven+Mysql+Tomcat+可以用于学习
06-05
物流快递系统前、后端+Java语言+SpringBoot项目+MVC三层架构+maven+Mysql+Tomcat+可以用于学习SpringBoot项目入门 1、Jdk：1.8.0_151 2、Tomcat:8.5.61 3、Mysql:Mysql57 4、Navicat for MySQL 5、IDEA:IntelliJ ...
IDEA Maven 三层架构 2、运行 springMVC
weixin_34190136的博客
09-21 171
运行 SpringMVC 首先要理解 SpringMVC 应用程序的入口是配置文件 web.xml，其路径为“src/main/webapp/WEB-INF/web.xml”，通过它再去关联 SpringMVC 的配置文件 springmvc-config.xml。 所涉及文件如下图： 此处列举了 web.xml 最精简的配置： <?xml version="1.0" encoding="...
三层架构图
09-25
三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为：表现层（UI）、业务逻辑层（BLL）、数据访问层（DAL）。区分层次的目的即为了“高内聚，低耦合”的思想。
Spring MVC+Maven 实现前端和后台交互源码
12-08
这是结合博客的源码，链接是：http://blog.csdn.net/u012660464/article/details/53508757 。名为：Spring MVC+Maven 实现同一项目的前端和后台交互，该源码示例了前端和后台如何进行参数的绑定传递。
Marco's Java【Maven入门(四) 之 按MVC三层结构分配Maven项目】
馬克兒的私人博客
07-31 392
前言 在经过前面的阶段学习之后，我们已经对项目与项目之间传递依赖已经有所认知啦，可能不少朋友会有疑惑，我之前做项目的时候需要什么jar包就把需要的jar包复制粘贴就好，哪用这么麻烦，为导个jar包，还多费周折去学习一个新的知识点，还要做那么多的配置，吃力不讨好吧？ 其实大多数初学者都会这么去想，但是实际开发我中我们还是会使用Maven这么去做，肯定是有它的道理，因为我们现在市面上开发的项目不仅仅是...
JavaWeb——后端之maven
qq_44689664的博客
01-04 788
javaweb、maven
IDEA Maven 三层架构 1、基本的Archetype 搭建
weixin_33912246的博客
09-21 552
JDK：1.8 Maven：3.3.9 三层架构：基于 SpringMVC 的 UI 层、业务逻辑层以及数据访问层 从对 Maven 的了解可以看出，三层架构的创建在于对文件夹的合理安排，他们通常是主子结构，其次还要运用到 Maven 的聚合和继承。 基本的 Archetype 搭建 创建 sln 组件。直接使用空架构创建即可： 顺便建立项目，并完善项目的名称和路径等信息： 项目(工程)...
前端vue项目打包,后端maven项目打包
Ryan_black的博客
05-12 2115
前端vue直接在VScode里输入命令 npm run build 前端会多出来这样一个文件,就是打包后的文件 后端maven打包,找到root的模块: 先执行clean,然后执行install. 项目就会自动打包,每一个模块的target文件中都会多一个.jar文件,就是我们打包后的文件 ...
后端Web基础(Maven基础)
m0_47698312的博客
12-16 925
1. Maven初识1. Maven初识1.1 什么是Maven?Maven 是一款用于管理和构建Java项目的工具，是Apache旗下的一个开源项目。Apache 软件基金会，成立于1999年7月，是目前世界上最大的最受欢迎的开源软件基金会，也是一个专门为支持开源项目而生的非盈利性组织。1.2 Maven的作用1.2.1 依赖管理方便快捷的管理项目依赖的资源(jar包)，避免版本冲突问题。项目中要想使用某一个jar包，就需要把这个jar包从官方网站下载下来，然后再导入到项目中。
使用maven三层结构创建企业级项目
AngelaCSDN的专栏
04-30 686
使用maven三层结构创建企业级项目的目录结构（仅用于示例）如下图： 说明： 1、wroot为整个项目的根目录； 创建Maven Project，项目配置 Packaging 是 pom . 2、二级项目： 创建为Maven Module，项目配置 Packaging 是 pom . wframe 用于放置框架相关服务； wcore 用于放置核心代码相关服务； sys 用于放置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值