在idea中使用spring boot创建jsp工程

在idea中使用sprint boot创建jsp工程

jsp技术简介

JSP(全称JavaServer Pages)是由Sun Microsystems公司主导创建的一种动态网页技术标准。JSP部署于网络服务器上,可以响应客户端发送的请求,并根据请求内容动态地生成HTML、XML或其他格式文档的Web网页,然后返回给请求者。JSP技术以Java语言作为脚本语言,为用户的HTTP请求提供服务,并能与服务器上的其它Java程序共同处理复杂的业务需求。

jsp技术实现思路

JSP将Java代码和特定变动内容嵌入到静态的页面中,实现以静态页面为模板,动态生成其中的部分内容。JSP引入了被称为“JSP动作”的XML标签,用来调用内建功能。另外,可以创建JSP标签库,然后像使用标准HTML或XML标签一样使用它们。标签库能增强功能和服务器性能,而且不受跨平台问题的限制。JSP文件在运行时会被其编译器转换成更原始的Servlet代码。JSP编译器可以把JSP文件编译成用Java代码写的Servlet,然后再由Java编译器来编译成能快速执行的二进制机器码,也可以直接编译成二进制码。

在idea中使用spring boot搭建jsp开发环境

spring boot已经成为时下最流行的java开发框架,为了让同学们能够在最新java开发技术基础上使用jsp开发技术,本次课程将直接在spring boot的基础上搭建jsp的开发环境。

1、spring boot简介

Spring boot是Spring家族中的一个全新的框架,它用来简化Spring应用程序的创建和开发过程,简化了软件开发环境和java 库的配置过程,提高了软件开发效率。

2.在idea中使用Spring Initializr创建并测试spring boot程序

1、file——new——project(或者mudole)。选中spring initializr。我们选择默认的初始化下载jar的网址即可。点击next


1.png

如下图,配置即可。

新建bootstrap项目.png

点击下一步,界面如下图,该界面罗列和很多常用的spring boot常用的插件,通过选择这些插件,idea工具会自动帮我们把插件加入到工程中。我们本次创建的是一个web项目,所以选中如图中的按钮。

选择springboot依赖.png

点击下一步,设置项目名字和存储路径,然后点击finish,到此项目创建成功。

设置springboot项目目录和保存路径.png

创建好以后,文件的列表如下图所示:

springboot项目文件结构.png
各个目录作用解释如下:

1.(.mvn)目录,项目自动创建的maven相关插件目录。
2.(src)开发项目的所有代码写在这个文件夹中。
3.(resources)目录是项目的静态资源文件,所有不被编译的文件都可以放入这个目录当中,如项目的配置文件application.properties或者项目中使用到的图片文件等。
4.test目录是测试文件,所有的单元测试代码都写在这个文件当中
5.mvmw maven脚本文件,用于在linux文件系统中打包使用。
6、mvmw.cmd maven脚本文件,用于在windows系统中打包项目使用
7、pom.xml 中包括了项目所使用的依赖配置和插件。

3.pom文件解释

<?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>
    <!--继承springboot的父级依赖-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <!--项目的相关信息-->
    <groupId>com.example.demo</groupId>
    <artifactId>01-springboot-web</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>01-springboot-web</name>
    <description>Demo project for Spring Boot</description>
    <!--属性配置-->
    <properties>
        <!--jdk版本-->
        <java.version>1.8</java.version>
    </properties>
<!--相关的依赖信息-->
    <dependencies>
        <!--springboot开发web项目的起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <!--此依赖不需要写版本号,以为我们上面已经继承了springboot的父级依赖-->
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--测试的起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
<!--编译-->
    <build>
        <plugins>
            <!--springboot提供的项目打包编译插件-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

4.springboot的入口main方法

spring boot不同于传统的spring mvc项目。路径为: com.example.demo.DemoApplication.java

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//@SpringBootApplication注解,表示这是springboot程序
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
//        这个方法是启动自己application.class 这个类,这样他就能启动springboot程序,然后启动spring容器,然后启动内嵌的Tomcat
        SpringApplication.run(Application.class, args);
    }
}

5.创建一个controller类

创建controller类后,目录结构如下图所示

controller目录.png

HelloController.java文件的代码如下图所示:

package com.cjp.springboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {

    @RequestMapping("/boot/hello")  //请求路径
    public @ResponseBody  String hello(){
        return "hello the world!";
    }
}

6.测试springboot程序

创建程序到此已经结束了。下面我们启动一下: 在目录中选中application——右击——“run application”。等待编译完成。编译完成后,显示端口为8080

springboot 启动成功后在控制台的提示.png

到此,springboot程序启动成功了,然后在浏览器中输入测试地址,查看结果

springboot 测试结果.png

7.发布springboot程序

项目项目已经完成了,如果需要发布也非常的简单。因为我们已经在pom 文件中引入了打包依赖 ,借助这个工具可以很方便的发布springboot程序

<!--编译-->
    <build>
        <plugins>
            <!--springboot提供的项目打包编译插件,可以将应用打包成一个可执行的jar包-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

我们只需要点击idea中的maven——lifecycle——package。

maven打包按钮位置.png

找到jar后,我们可以在命令行窗口执行java -jar spring-boot-01-helloworld-1.0-SNAPSHOT.jar 即可。 启动后,我们可以在浏览器中直接访问localhost:8080/boot/hello,可以查看执行结果。。

8.spring boot总结

  1. 在这个程序,我们使用到了spring mvc,但是我们并没有注入spring mvc 的配置文件,也不需要在Tomcat中部署,同样不需要引入很多的jar包。这是因为我们在前面的springboot开发web项目的起步依赖中已经自动引入了需要依赖的jar

  2. spring boot 的父级依赖spring-boot-starter-parent配置之后,当前项目变成了spring boot 项目

  3. spring -boot-starter-parent 是一个特殊的starter依赖,它用来提供相关的maven默认依赖,使用它之后,常用的jar包依赖可以省去version 配置。我们在查看pom.xml 文件发现我们的相关依赖项都是没有填写版本号的。这是因为 springboot的父级依赖是Spring Boot的版本仲裁中心,以后我们导入依赖默认是不需要写版本;(没有在dependencies里面管理的依赖自然需要声明版本号)

  4. spring boot 提供了很多的默认的jar 依赖,可以通过查看spring boot 的父级依赖。

  5. 如果不想使用某个默认的依赖版本,可以通过修改pom .xml 文件属性配置,从而覆盖各个依赖项。比如覆盖spirng 版本。

  6. @springbootapplication 注解是springboot项目的核心注解,主要作用的开启springboot的自动配置。

  7. main 方法是一个标准的java程序的main 方式,主要作用是作为项目的启动入口

  8. @controller和@responseBody 依然是spring mvc的内容,因为spring boot 的里面最常用的是spring mvc + spring + mybatis 框架

添加jsp支持

springboot并没有默认支持jsp,要想让springboot支持jsp,需要添加jstl标签库并给tomcat添加jsp编译支持。

1、在pom文件中添加jsp支持

    <!-- javaServer Pages standard tag library jsp标准标签库-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>
        <!--内置tomcat对jsp支持的依赖,用于编译jsp-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>

2.配置jsp模板路径

resources/application.properties文件中添加jsp模板文件的配置路径

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp

prefix 用于指定jsp文件的路径,suffix用于指定jsp文件的后缀名

3、添加controller

通过返回ModelAndView和String两种方式使用jsp

@Controller
public class HelloController {
    @ResponseBody
    @RequestMapping("/hi")
    public String hi(){
        return "h1";
    }
    //通过返回ModelAndView方式实现
    @RequestMapping("/hello")
    public ModelAndView hello(HttpServletResponse response)throws IOException {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("hello");
        modelAndView.addObject("username","李白");
        return modelAndView;
    }
    //通过返回String实现
    @RequestMapping("/abc")
    public String abc(){
        return "hello";
    }
}

4.建立jsp页面

根据resources/application.properties配置文件的描述,controller中abc路径返回的hello页面的完整路径应该是webapp/WEB-INF/jsp/hello.jsp。其路径结构如图所示

jsp路径.png

然后在jsp页面中添加代码如下

<%@page contentType="text/html; charset=UTF-8" language="java" %>
<html>
<head>

</head>
<body>
<div class="container">
 jsp页面
</div>

</body>
</html>

至此完成第一个jsp页面的建立,其测试过程同前面springboot测试过程,这里不再赘述。

5.添加jsp支持总结

  1. springboot已经不再讲自己定义为单一的web开发框架,而是将所有java开发模式都纳入到框架中来,所以不再默认支持jsp,若需要使用jsp。则需要手动添加jsp支持。

  2. 添加jsp支持需要在pom中添加两个库文件jstl标签库内置tomcat编译jsp的支持库

  3. 需要配置jsp的文件路径和后缀名

  4. 在controller中使用jsp编程有两种方式:返回ModelAndViewString两种方式

编程体验优化

在前面的编程练习过程当中,我们发现有两个地方比较麻烦,一是在首次加载pom中的库的时候比较耗时,二是每次修改代码后都需要重启服务器才能生效。下面讲解解决这两个问题的方法。

1、解决pom中库下载慢的问题

出现这种问题的原因在于pom中所有的库都是默认从核心仓库中下载的,而核心仓库在国外,因此导致下载速度慢。好在阿里巴巴做了pom库的镜像,通过将maven的下载镜像配置到阿里巴巴的镜像源,可以加快pom库的下载速度。具体操作不走如下:

在idea中点击file->settings 打开如下窗口,然后在左上角搜索maven,将右下角的User setting file的Override复选框选中,这一步可以容许我修改settings.xml文件来配置maven的默认操作

maven_settings.png

按照上述目录打开maven的settings文件,若没有setting文件可手动创建一个settings.xml文件。将里面内容填写如下:

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
    <mirrors>
        <!-- 阿里云仓库 -->
        <mirror>
            <id>aliyun-public</id>
            <mirrorOf>*</mirrorOf>
            <name>aliyun public</name>
            <url>https://maven.aliyun.com/repository/public</url>
        </mirror>

        <mirror>
            <id>aliyun-central</id>
            <mirrorOf>*</mirrorOf>
            <name>aliyun central</name>
            <url>https://maven.aliyun.com/repository/central</url>
        </mirror>

        <mirror>
            <id>aliyun-spring</id>
            <mirrorOf>*</mirrorOf>
            <name>aliyun spring</name>
            <url>https://maven.aliyun.com/repository/spring</url>
        </mirror>

        <mirror>
            <id>aliyun-spring-plugin</id>
            <mirrorOf>*</mirrorOf>
            <name>aliyun spring-plugin</name>
            <url>https://maven.aliyun.com/repository/spring-plugin</url>
        </mirror>

        <mirror>
            <id>aliyun-apache-snapshots</id>
            <mirrorOf>*</mirrorOf>
            <name>aliyun apache-snapshots</name>
            <url>https://maven.aliyun.com/repository/apache-snapshots</url>
        </mirror>

        <mirror>
            <id>aliyun-google</id>
            <mirrorOf>*</mirrorOf>
            <name>aliyun google</name>
            <url>https://maven.aliyun.com/repository/google</url>
        </mirror>

        <mirror>
            <id>aliyun-gradle-plugin</id>
            <mirrorOf>*</mirrorOf>
            <name>aliyun gradle-plugin</name>
            <url>https://maven.aliyun.com/repository/gradle-plugin</url>
        </mirror>

        <mirror>
            <id>aliyun-jcenter</id>
            <mirrorOf>*</mirrorOf>
            <name>aliyun jcenter</name>
            <url>https://maven.aliyun.com/repository/jcenter</url>
        </mirror>

        <mirror>
            <id>aliyun-releases</id>
            <mirrorOf>*</mirrorOf>
            <name>aliyun releases</name>
            <url>https://maven.aliyun.com/repository/releases</url>
        </mirror>

        <mirror>
            <id>aliyun-snapshots</id>
            <mirrorOf>*</mirrorOf>
            <name>aliyun snapshots</name>
            <url>https://maven.aliyun.com/repository/snapshots</url>
        </mirror>

        <mirror>
            <id>aliyun-grails-core</id>
            <mirrorOf>*</mirrorOf>
            <name>aliyun grails-core</name>
            <url>https://maven.aliyun.com/repository/grails-core</url>
        </mirror>

        <mirror>
            <id>aliyun-mapr-public</id>
            <mirrorOf>*</mirrorOf>
            <name>aliyun mapr-public</name>
            <url>https://maven.aliyun.com/repository/mapr-public</url>
        </mirror>

        <!-- 中央仓库1 -->
        <mirror>
            <id>repo1</id>
            <mirrorOf>central</mirrorOf>
            <name>Human Readable Name for this Mirror.</name>
            <url>http://repo1.maven.org/maven2/</url>
        </mirror>


        <!-- 中央仓库2 -->
        <mirror>
            <id>repo2</id>
            <mirrorOf>central</mirrorOf>
            <name>Human Readable Name for this Mirror.</name>
            <url>http://repo2.maven.org/maven2/</url>
        </mirror>
    </mirrors>

</settings>

文件中13个mirror标签,每个mirror标签代表一个镜像源。最后两个是默认的中央仓库,速度一般比较慢,前面11个都是阿里云的源。当maven下载库的时候就会从上往下依次测试每个源是否可以下载当前库,若能下载则采用当前源,若不能下载则测试下一个源。因此,阿里云的源必须配置在中央仓库的前面才能生效。

2、springboot 热部署

springboot热部署的实现思路是使用spring-boot-devtools监听classpath下的文件变动并立即重启应用。通过配置springboot热部署,可以使代码保存后立马生效,配置步骤如下:

在pom文件中添加spring-tool-devtools依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

<plugin>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-maven-plugin</artifactId>
   <configuration>
      <fork>true</fork> <!-- 如果没有该配置,devtools不会生效 -->
   </configuration>
</plugin>

optional标签中的 true表示依赖不会传递。 若要额外监听其他路径下的文件可通过在src/main/resources/application.properties中添加配置实现。如通过如下配置让deltool监听application.properties文件的变化

#热部署生效
spring.devtools.restart.enabled=true
#设置重启的目录,检索目录(resources/static、resources/templates)
spring.devtools.restart.additional-paths= src/main/java
#classpath目录下的WEB-INF文件夹内容修改不重启
#spring.devtools.restart.exclude= WEB-INF/**

在idea中修改配置,勾选Build project automatically

image-20191118160613293.png

按 ctrl+shift+alt+/,选择Registry,勾选图示选项。

image-20191118160829593.png

做完以上步骤后就可以实现热加载了。但通过测试后发现热加载的反应有点慢,需在使用过程中特别关注控制台信息。

推荐阅读更多精彩内容