Wie integriert SpringBoot Jsp und Thymeleaf?

Der Inhalt dieses Artikels befasst sich mit der Integration von Jsp und Thymeleaf. Ich hoffe, dass er für Freunde in Not hilfreich ist.

Vorwort

In diesem Artikel geht es hauptsächlich um die SpringBoot-IntegrationJsp und SpringBoot-IntegrationThymeleaf, Implementieren Sie ein einfaches Beispielprojekt zum Hinzufügen, Löschen, Ändern und Abfragen von Benutzern. Um es vorweg zu sagen: Es gibt drei Elemente, zwei einzeln integriert und eines, das sie alle zusammen integriert. Wenn Sie eines davon benötigen, schauen Sie sich einfach die Einleitung des entsprechenden Abschnitts an. Wenn Sie den Quellcode des Projekts benötigen, können Sie direkt nach unten springen und den Projektcode über den Link herunterladen.

SpringBoot-Integration Jsp

Entwicklungsvorbereitung

Umgebungsanforderungen
JDK: 1.7 oder höher
SQL: MySql

Hier müssen wir eine Benutzertabelle in MySQL erstellen, um Benutzerinformationen zu speichern.
Das Datenbankskript lautet wie folgt:

CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '自增id',
  `name` varchar(10) DEFAULT NULL COMMENT '姓名',
  `age` int(2) DEFAULT NULL COMMENT '年龄',
  `password` varchar(24) NOT NULL COMMENT '密码',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=17 DEFAULT CHARSET=utf8

Nachdem wir die neue Tabelle erstellt haben, erstellen wir das Projekt.
Unser Projekt ist ein gewöhnliches Webprojekt, das mit Maven erstellt wurde.
Nachdem wir das Projekt erstellt haben, müssen wir das entsprechende JAR-Paket herunterladen und dann die entsprechende Entwicklung durchführen.
Für diese JAR-Pakete können wir einfach SpringBoot- und JSP-bezogene JARs in die Datei pom.xml einfügen.
Die relevanten Hinweise sind darin enthalten, daher werde ich hier nicht näher darauf eingehen.
Maven-Abhängigkeiten sind wie folgt:

 <dependencies>
        <!-- Spring Boot Web 依赖 核心 -->
        <dependency>
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- Spring Boot 热部署 class文件之后会自动重启 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- Spring Boot Test 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!-- Spring Boot JPA -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        
          <!-- Spring Boot Mybatis 依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis-spring-boot}</version>
        </dependency>
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        
        <!--fastjson 相关jar -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson}</version>
        </dependency>
        
                <!--JSP 依赖  -->
        <!-- servlet依赖. -->  
        <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>jstl</artifactId>
        </dependency>  
        
        <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>javax.servlet-api</artifactId>
            <scope>provided</scope>  
        </dependency>  
       
        <!-- tomcat的支持.-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>provided</scope>
        </dependency>    
  </dependencies>

Nachdem das entsprechende Jar-Paket heruntergeladen wurde, bestätigen wir die Projektstruktur.
Das erste ist die hintergrundbezogene Paketbeschreibung:

src/main/java
com.pancm.web - Controller 层
com.pancm.dao - 数据操作层 DAO
com.pancm.pojo- 实体类
com.pancm.service - 业务逻辑层
Application - 应用启动类

src/main/resources
application.properties - 应用配置文件，应用启动会自动读取配置

Front-End-bezogene Dateispeicherbeschreibung:

src/main/webapp
WEB-INF - web.xml web相关的核心配置
WEB-INF/jsp - JSP文件的存放路径

Gesamtprojektstrukturdiagramm:

Projektstruktur Nach Bestätigung fügen wir die entsprechende Konfiguration hinzu.
Fügen Sie einfach die entsprechende Konfiguration in application.properties hinzu.
Die Konfiguration der Datenquelle ähnelt der vorherigen. Zu beachten ist die zugehörige Konfiguration von Jsp.
Da die von springBoot unterstützte Standardvorlage Thymeleaf ist, müssen wir hier entsprechende Änderungen vornehmen.

Die Konfiguration ist wie folgt:

## 编码
banner.charset=UTF-8
server.tomcat.uri-encoding=UTF-8
spring.http.encoding.charset=UTF-8
spring.http.encoding.enabled=true
spring.http.encoding.force=true
spring.messages.encoding=UTF-8
## 端口
server.port=8088

## 数据源
spring.datasource.url=jdbc:mysql://localhost:3306/springBoot?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

## JSP配置
# 页面默认前缀
spring.mvc.view.prefix=/WEB-INF/jsp/
# 响应页面默认后缀
spring.mvc.view.suffix=.jsp

Code schreiben

Tatsächlich ist der Code hier im Wesentlichen derselbe wie der im vorherigen Artikel beschriebene Der einzige Unterschied besteht darin, dass ich hier JPA zum Betrieb der Datenbank verwende (also übrigens die Verwendung des JPA-Frameworks).

Die erste ist die Entitätsklasse, da hier JPA verwendet wird. Sie unterscheidet sich ein wenig von der vorherigen Klasse und es wurden einige Anmerkungen hinzugefügt.
Entity: Zeigt an, dass es sich um eine Entitätsklasse handelt.
Tabelle: Der Name der Datentabelle, die von dieser Entitätsklasse zugeordnet wird.
Spalte: Geben Sie die Attribute des Felds an. Nullable gibt an, ob es nicht leer ist, und Unique gibt an, ob es eindeutig ist.

Dann lautet der Code der Entitätsklasse wie folgt:

@Entity
@Table(name = "t_user")
public class User {
    
     /** 编号 */
     @Id
     @GeneratedValue
     private Long id;
     /** 姓名 */
     @Column(nullable = false, unique = true)
     private String name;
     /** 密码*/
     @Column(nullable = false)
     private String password;
     /** 年龄 */
     @Column(nullable = false)
     private Integer age;
    
    //getter和setter略
}

Da JPA verwendet wird, muss die Dao-Schicht nur das JpaRepository erben class müssen Sie die Entitätsklasse und den Primärschlüsseltyp angeben.
Der Dao-Layer-Code lautet wie folgt:

@Mapper
public interface UserDao extends JpaRepository<User, Long>{
    
}

Die Business-Schicht kann wie zuvor aufgerufen werden, die Methode ist jedoch auch sehr einfach . Verwenden Sie „Speichern“, um zu löschen, „findOne“, um nach ID zu suchen, „findAll“, um alle abzufragen usw.

Der Dienstcode lautet wie folgt:

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;
    
    
    @Override
    public boolean addUser(User user) {
        boolean flag=false;
        try{
            userDao.save(user);
            flag=true;
        }catch(Exception e){
            System.out.println("新增失败!");
            e.printStackTrace();
        }
        return flag;
    }

    @Override
    public boolean updateUser(User user) {
        boolean flag=false;
        try{
            userDao.save(user);
            flag=true;
        }catch(Exception e){
            System.out.println("修改失败!");
            e.printStackTrace();
        }
        return flag;
    }

    @Override
    public boolean deleteUser(Long id) {
        boolean flag=false;
        try{
            userDao.delete(id);
            flag=true;
        }catch(Exception e){
            System.out.println("删除失败!");
            e.printStackTrace();
        }
        return flag;
    }

    @Override
    public User findUserById(Long id) {
        return userDao.findOne(id);
    }

    @Override
    public List<User> findAll() {
        return userDao.findAll();
    }
}

Wenn es um die Kontrollschicht geht, stellen wir hier immer noch eine Schnittstelle zum Aufrufen von Jsp bereit, aber die Anmerkungen der Die Klasse hier kann die vorherige Annotation RestController nicht verwenden. Diese Annotation gibt Daten im JSON-Format zurück, aber manchmal müssen wir bei der Rückkehr zur Schnittstelle springen, daher sollten wir die Annotation Controller verwenden. Wenn das Datenformat, das Sie in einer Methode zurückgeben möchten, JSON ist, fügen Sie der Methode einfach die Annotation ResponseBody hinzu.

Der Code der Kontrollschicht lautet wie folgt:

@Controller
public class UserRestController {
        @Autowired
        private UserService userService;
 
        @RequestMapping("/hello")
        public String hello() {
            return "hello";
        }
        
        @RequestMapping("/")
        public String index() {
            return "redirect:/list";
        }
        
        
        @RequestMapping("/list")
        public String list(Model model) {
            System.out.println("查询所有");
            List<User> users=userService.findAll();
            model.addAttribute("users", users);
            return "user/list";
        }

        @RequestMapping("/toAdd")
        public String toAdd() {
            return "user/userAdd";
        }

        @RequestMapping("/add")
        public String add(User user) {
            userService.addUser(user);
            return "redirect:/list";
        }

        @RequestMapping("/toEdit")
        public String toEdit(Model model,Long id) {
            User user=userService.findUserById(id);
            model.addAttribute("user", user);
            return "user/userEdit";
        }

        @RequestMapping("/edit")
        public String edit(User user) {
            userService.updateUser(user);
            return "redirect:/list";
        }


        @RequestMapping("/toDelete")
        public String delete(Long id) {
            userService.deleteUser(id);
            return "redirect:/list";
        }
}

Funktionstest

Das war's für die Einführung des Back-End-Codes Ich werde nicht auf Details des Front-End-JSP-Codes eingehen (der Hauptgrund ist, dass die Schnittstelle zu hässlich ist ...), wir starten das Projekt direkt und überprüfen die Wirkung.
Starten Sie das Projekt und geben Sie ein: http://localhost:8088/list
Hauptschnittstelle:

Nach dem Hinzufügen einer Datenschnittstelle:

Andere Änderungen und Löschungen sind ebenfalls möglich, hier werden wir keine Bilder einzeln posten.
Dies ist das Ende der SpringBoot-Integration JSP.

SringBoot integriert Thymeleaf

Einführung in Thymeleaf

Thymeleaf ist eine Template-Engine, die für Web- und Nicht-Web-Anwendungen verwendet werden kann. Sie kann mit XML/XHTML/HTML5 arbeiten , JavaScript, CSS und sogar Textdateien.

Verwendung von Thymeleaf

Ich beherrsche die Verwendung von Thymeleaf nicht. Dies ist nicht der Hauptinhalt dieses Artikels. Weitere Informationen finden Sie in der offiziellen Dokumentation.
https://www.thymeleaf.org/documentation.html

Entwicklungsvorbereitung

Es ist im Grunde dasselbe wie das oben genannte SringBoot-Integrations-JSP, daher werde ich nicht auf Details eingehen Hier.

由于SpringBoot默认的模版引擎就是Thymeleaf，所以Maven 依赖这块只需要在原先的springBoot项目添加Thymeleaf的依赖就行。

  <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
 </dependency>

application.properties 配置这块，可以和之前的项目基本一致，需要注意的也只有spring.thymeleaf.cache配置，为false的时候是关闭Thymeleaf的缓存，更改界面之后会自动重启然后生效。

SringBoot整合Thymeleaf和SringBoot整合Jsp有个比较大的不同是，Thymeleaf的资源文件是放在src/main/resources目录下，Jsp的是放在src/main/webapp目录下。其中resources目录下的的static目录用于放置静态内容，比如css、js、jpg图片等。templates目录用于放置项目使用的页面模板，也就是.html文件。

它的项目结构图如下:

代码基本和SringBoot整合Jsp一致，这里就不在赘述了。

功能测试

启动该项目，在浏览器输入:http://localhost:8085
主界面:

修改用户数据之后的:

其它的功能也是可以实现的，这里就不再过多贴图了。
springBoot整合 Thymeleaf到这就结束了。

SpringBoot整合Jsp和Thymeleaf

注:这个是后来新加的一个项目。
SpringBoot单独整合Jsp和Thymeleaf都还好，没出现什么问题。但是在一起之后，就有了改变，因为SpringBoot默认的模板引擎是Thymeleaf，加上JSP之后，JSP的模板引擎并不会生效。但是如果想用JSP模板，此时的禁用到Thymeleaf，虽然可以通过多态更改配置实现，但是感觉太过麻烦了。于是研究了一下，找到了共存的方法。

和前面来两个项目区别如下：

1. 之前的Jsp和Thymeleaf配置都是在application.properties
   文件中，这里我将它们的配置改到代码中获取。

2.之前Thymeleaf相关文件是放在 src/main/resources 目录下，这里移动到WEB-INF目录下，和之前的jsp文件夹同级。

3.增加一个控制层，严格区分访问Jsp和Thymeleaf的路径。访问Jsp的路径前缀加上jsp，访问Thymeleaf前缀加上templates。

那么新增的配置代码如下:

@Configuration
@EnableWebMvc
@ComponentScan
public class WebConfig extends WebMvcConfigurerAdapter {
    
       @Bean
       public ViewResolver viewResolver() {
           InternalResourceViewResolver resolver = new InternalResourceViewResolver();
           resolver.setPrefix("/WEB-INF/");
           resolver.setSuffix(".jsp");
           resolver.setViewNames("jsp/*");
           resolver.setOrder(2);
           return resolver;
       }

       @Bean
       public ITemplateResolver templateResolver() {
           SpringResourceTemplateResolver templateResolver = new SpringResourceTemplateResolver();
           templateResolver.setTemplateMode("HTML5");
           templateResolver.setPrefix("/WEB-INF/");
           templateResolver.setSuffix(".html");
           templateResolver.setCharacterEncoding("utf-8");
           templateResolver.setCacheable(false);
           return templateResolver;
       }

       @Bean
       public SpringTemplateEngine templateEngine() {
           SpringTemplateEngine templateEngine = new SpringTemplateEngine();
           templateEngine.setTemplateResolver(templateResolver());
           return templateEngine;
       }

       @Bean
       public ThymeleafViewResolver viewResolverThymeLeaf() {
           ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
           viewResolver.setTemplateEngine(templateEngine());
           viewResolver.setCharacterEncoding("utf-8");
           viewResolver.setViewNames(new String[]{"thymeleaf/*"});
           viewResolver.setOrder(1);
           return viewResolver;
       }

       @Override
       public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
           configurer.enable();
       }

       @Override
       public void addResourceHandlers(ResourceHandlerRegistry registry) {
           super.addResourceHandlers(registry);
       }
}

项目的结构图如下:

功能测试

在浏览器输入:http://localhost:8089/list
查看Thymeleaf模板的界面

在浏览器输入:http://localhost:8089/list2
查看JSP模板的界面

可以看到已经成功整合。

关于SpringBoot整合Jsp和Thymeleaf 到这里就结束了。
SpringBoot整合Jsp的项目工程地址:
https://github.com/xuwujing/springBoot-study/tree/master/springboot-jsp-jpa
SpringBoot整合Thymeleaf的项目工程地址:
https://github.com/xuwujing/springBoot-study/tree/master/springboot-thymeleaf
SpringBoot整合Jsp和Thymeleaf的项目工程地址:
https://github.com/xuwujing/springBoot-study/tree/master/springboot-jsp-thymeleaf

相关推荐：

SpringBoot整合Netty并使用Protobuf进行数据传输的实现过程

SpringBoot如何进行简单的打包部署？

Das obige ist der detaillierte Inhalt vonWie integriert SpringBoot Jsp und Thymeleaf?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!