springboot打包

springboot打包

打为war包

过程如下 :

1. pom文件中加入依赖

		<!--加入jsp的依赖-->
		<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>

2. 在build标签中指定jsp文件的编译目录

		<resources>
			<!--把jsp编译到META-INF/resources目录中-->
			<resource>
				<directory>
					src/main/webapp
				</directory>
				<targetPath>META-INF/resources</targetPath>
				<includes>
					<include>**/*.*</include>
				</includes>
			</resource>

			<!--使用了mybatis,而且mapper文件放在src/main/java目录下-->
			<resource>
				<directory>src/main/java</directory>
				<includes>
					<include>**/*.xml</include>
				</includes>
			</resource>

			<!--把src/main/resources下的所有文件都包含在classes目录下-->
			<resource>
				<directory>src/main/resources</directory>
				<includes>
					<include>*.*</include>
				</includes>
			</resource>
		</resources>

3. 在build标签中指定打包后的war包名称

		<!--打包后的文件名称-->
		<finalName>myboot</finalName>

4. 创建webapp目录,并且创建jsp文件
   
   需要将创建好的文件设置为资源文件
5. 创建视图层

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class JspController {

    @RequestMapping("/main")
    public String main(Model model) {
        model.addAttribute("data", "springboot打包为war文件");
        return "index";
    }
}

6. 修改application.properties里的内容

#视图解析器
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

注意这里可以不用配置端口号,因为打包为war包使用的是外部的tomcat服务器,使用的是tomcat的端口,而不是springboot的端口
7. 主类需要继承SpringBootServletInitiallizer
由于打成包后需要在外部使用tomcat,需要继承SpringBootServletInitializer,并重写configure方法

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

/**
 * 在外部使用tomcat需要继承SpringBootServletInitializer
 * 并重写configure方法
 */
@SpringBootApplication
public class Application extends SpringBootServletInitializer {

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}

	@Override
	protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
		return builder.sources(Application.class);
	}
}

8. 使用maven package打包
   
9. 将打包好的文件放在本机tomcat的webapps目录下
   
10. 启动应用
    启动过程如下 :
    首先先启动本地的tomcat服务器,即运行tomcat目录下bin文件的startup.bat,此时会将war包自动解压在webapps目录下
    
    此时不要关闭startup.bat,将myboot.war包自动解压为myboot,这时/myboot就是访问项目的项目名
    此时就可以直接访问了,由于使用的是外部的tomcat服务器,那么将访问的端口就是tomcat的端口,项目名为解压缩后的文件名称.

打为jar包

过程如下 :

1. pom文件中加入相关依赖

		<!--加入jsp的依赖-->
		<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>

2. 在build标签中指定文件编译后的目录

		<resources>
			<!--把jsp编译到META-INF/resources目录中-->
			<resource>
				<directory>
					src/main/webapp
				</directory>
				<targetPath>META-INF/resources</targetPath>
				<includes>
					<include>**/*.*</include>
				</includes>
			</resource>

			<!--使用了mybatis,而且mapper文件放在src/main/java目录下-->
			<resource>
				<directory>src/main/java</directory>
				<includes>
					<include>**/*.xml</include>
				</includes>
			</resource>

			<!--把src/main/resources下的所有文件都包含在classes目录下-->
			<resource>
				<directory>src/main/resources</directory>
				<includes>
					<include>*.*</include>
				</includes>
			</resource>
		</resources>

3. 创建webapp项目,并且创建jsp文件
4. 创建视图层
5. 修改application.properties

server.port=8081
server.servlet.context-path=/myjsp

#视图解析器
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

这里需要配置端口号,因为jar包本身还是使用自己的内置tomcat服务器,需要使用自己配置的端口号和项目名称

6. 在plugin标签中设置插件版本,这个也在build标签中

		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<!--打包为jar包,有jsp文件时必须指定唯一的一个版本-->
				<version>1.4.2.RELEASE</version>
			</plugin>
		</plugins>

7. 执行maven package
8. 启动应用
   在jar包的位置执行jar,启动内置tomcat
   即在jar包的位置执行cmd命令

java -jar myboot.jar

9. 访问项目
   使用application.properties配置的内容访问项目,这时使用的是内部的tomcat.

jar和war的区别

1. war包的启动需要服务器,由于本地服务器启动需要占用资源,耗费更多,不过可以更好的使用本地服务器的性能.
2. jar包比较小巧,使用更方便,不过由于使用的是内置的tomcat,导致性能上不如本地服务器.