springboot（三）_springboot flush-优快云博客

文章目录

springboot创建非WEB工程
- 方式一：main方法中取spring容器，调用业务层bean
- 方式二：入口类实现CommandLineRunnable接口
springboot拦截器
- ssm配置文件中怎么使用拦截器
- springboot拦截器（2步）
springboot使用servlet
- 注解扫描方式
- 配置类方式
springboot使用Filter
- 注解扫描方式
- 配置类方式
springboot配置字符编码
- 配置类方式
- 配置文件（推荐使用）
Springboot打包与部署
- war打包与部署
- jar打包与部署
springboot集成logback日志

springboot创建非WEB工程

方式一：main方法中取spring容器，调用业务层bean

application.java

@SpringBootApplication
public class Application {
	public static void main(String[] args) {
	/**
	* SpringBoot 程序启动后，返回值是 ConfigurableApplicationContext ，它也是一
	个 Spring 容器对象
	* 它其实相当于原来 Spring 中启动容器 ClassPathXmlApplicationContext context
	= new ClassPathXmlApplicationContext("");
	*/
	//获取 SpringBoot 程序启动后的 Spring 容器
	ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
	//从 Spring 容器中获取指定 bean 的对象
	UserService userService = (UserService)context.getBean("userServiceImpl");
	//调用业务 bean 的方法
	String sayHello = userService.sayHello();
	System.out.println(sayHello);
	}
}

方式二：入口类实现CommandLineRunnable接口

application.java

@SpringBootApplication
public class Application2 implements CommandLineRunner {
	//第二步：通过容器获取 bean，并注入给 userService
	@Autowired
	private UserService userService;
	public static void main(String[] args) {
		//第一步：SpringBoot 的启动程序，会初始化 spring 容器
		SpringApplication.run(Application2.class,args);
	}
	//覆盖接口中的 run 方法
	@Override
	public void run(String... args) throws Exception {
		//第三步：容器启动后调用 run 方法，在该方法中调用业务方法
		String sayHello = userService.sayHello();
		System.out.println(sayHello);
	}
}

springboot拦截器

ssm配置文件中怎么使用拦截器

定义拦截器类实现HandlerInterceptor接口，重写preHandle ，postHandle，afterCompletion三个方法

public class UserInterceptor implements HandlerInterceptor {
	@Override
	public boolean preHandle(HttpServletRequest request,HttpServletResponse response, Object handler) throws Exception {
		//编写登录拦截业务逻辑
		//返回 true 通过
		//返回 false 被拦截
		System.out.println("--------登录拦截器---------");
		return true;
	}
	@Override
	public void postHandle(HttpServletRequest request,HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
	
	}
	@Override
	public void afterCompletion(HttpServletRequest request,HttpServletResponse response, Object handler, Exception ex) throws Exception {
	
	}
}

dispatcherServlet.xml配置文件，注册拦截器

springboot拦截器（2步）

定义拦截器类，这一步不变，实现HandlerInterceptor接口，重写三个方法

public class UserInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String data = (String) request.getSession().getAttribute("data");
        /*
		这里的StringUtils和ObjectUtils来自commons-lang3依赖
		<dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
		*/
        if (StringUtils.equals("", data)|| !ObjectUtils.allNotNull(data)) {
            response.sendRedirect(request.getContextPath()+"/llerror");
            return false;
        }
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

定义配置类，这个类相当于配置文件对拦截器的注册，@Configuration表示当前类是配置类，需要实现WebMvc Configurer 接口，重写addInterceptors方法
IntercepterConfig.java

@Configuration
public class IntercepterConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        String [] addPath = { "/user/add","/user/center","/user/loan/**"};
        String [] excludePath={"/user/loan/loanInfo"};
		//       addInterceptor注册拦截器          addPathPatterns需要拦截的请求   excludePathPatterns拦截请求中可以排除的请求
        registry.addInterceptor(new UserInterceptor()).addPathPatterns(addPath).excludePathPatterns(excludePath);
    }
}

控制层发送请求，测试
UserController.java

@Controller
public class UserController {

	//可以显示
    @RequestMapping("/user/loan/loanInfo")
    public @ResponseBody Object loanInfo() {
        return "loanInfo 进来了,没被拦截";
    }
	//被拦截
    @RequestMapping("/user/add")
    public @ResponseBody Object add() {
        return "add 进来了";
    }
    //被拦截
    @RequestMapping("/user/loan")
    public @ResponseBody Object loan() {
        return "loan 进来了";
    }
    //不能使用error请求,使用/error请求会报BeanCreateException异常
    @RequestMapping("/llerror")
    public @ResponseBody Object loan() {
        return "error 进来了";
    }
}

springboot使用servlet

注解扫描方式

controller层，使用@WebServlet注解，参数使用urlPatterns表示接收的请求，需要继承HttpServlet类，重写doGet和doPost方法

@WebServlet(urlPatterns = "/myServlet")
public class MyServlet extends HttpServlet {
	@Override
	protected void doGet(HttpServletRequest request, HttpServletResponseresponse) throws ServletException, IOException {
		response.getWriter().print("My SpringBoot Servlet");
		response.getWriter().flush();
		response.getWriter().close();
	}
	@Override
	protected void doPost(HttpServletRequest request, HttpServletResponseresponse) throws ServletException, IOException {
		doGet(request,response);
	}
}

在主应用程序 Application 类上添加@ServletComponentScan(“com.abc.springboot.servlet”)
@ServletComponentScan 表示扫描@WebServlet注解，当然它不仅仅可以扫描servlet注解

@SpringBootApplication
@ServletComponentScan(basePackages = "com.abc.springboot.servlet")
public class Application {
	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
}

运行

配置类方式

创建一个普通的Servlet，注意这里不需要加@WebServlet注解

public class MyServlet extends HttpServlet {
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		resp.getWriter().print("Hello,SpringBoot Servlet!");
		resp.getWriter().flush();
		resp.getWriter().close();
	}
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		doGet(req,resp);
	}
}

编写配置类，注册servlet，这个配置类就相当于原先的配置文件web.xml。@Configuration注解表示这个类是配置类，ServletRegistrationBean 就是Servlet注册实体bean（字面意思）,需要@Bean注解修饰

@Configuration //这个注解表示将此类作为配置类
public class ServletConfig {
	//@Bean 是一个方法级别上的注解，主要用在配置类里
	/*
	* 相当于一个<beans>
	* <bean id="" class=""/>
	* </beans>
	* */
	@Bean
	public ServletRegistrationBean myServletRegistrationBean() {
		//将自定义 servlet 注册到注册 Servlet 类中，并指定访问路径
		ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new MyServlet(), "/springboot/myServlet");
		return servletRegistrationBean;
	}
}

运行

springboot使用Filter

注解扫描方式

通过注解方式创建一个 Filer，在过滤器类上面加上注解@WebFilter，和@WebServlet一样，urlPattern表示过滤请求，需要重写doFilter方法，当然它没有配置类

@WebFilter(urlPatterns = "/springboot/myFilter")
public class MyFilter implements Filter {
	@Override
	public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
		System.out.println("-------------您已进入过滤器---------------");
		filterChain.doFilter(servletRequest,servletResponse);
	}
}

在主应用程序 Application 类上添加@ServletComponentScan("basePackages = “com.abc.springboot.filter”)，扫描@WebFilter注解

@ServletComponentScan(basePackages = "com.abc.springboot.filter")
@SpringBootApplication
public class Application {
	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
}

运行
过滤/springboot/myFilter 请求

配置类方式

创建 MyFilter 类，实现Filter接口，实现doFilter方法

public class MyFilter implements Filter {
	@Override
	public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
		System.out.println("---------------通过配置类注册过滤器-------------------");
		filterChain.doFilter(servletRequest,servletResponse);
	}
}

编写一个 FilterConfig配置类，在该类中注册 Filter，使用@Configuration 声明这个类是配置类，FilterRegistrationBean 表示过滤器注册实体bean，使用@Bean 注解声明

@Configuration //定义为配置类
public class FilterConfig {
	@Bean
	public FilterRegistrationBean myFilterRegistration() {
		//注册过滤器
		FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new MyFilter());
		//添加过滤路径
		filterRegistrationBean.addUrlPatterns("/springboot/*","/user/*");
		return filterRegistrationBean;
	}
}

运行

springboot配置字符编码

配置类方式

创建一个 Servlet：MyServlet.java

public class MyServlet extends HttpServlet {
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp)throws ServletException, IOException {
		resp.getWriter().print("Hello World，世界您好！");
		//设置浏览器编码格式
		resp.setContentType("text/html;character=utf-8");
		resp.getWriter().flush();
		resp.getWriter().close();
	}
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp)throws ServletException, IOException {
		doGet(req, resp);
	}
}

创建配置类 SystemConfig

@Configuration //设置为配置类
public class SystemConfig {
	@Bean
	public ServletRegistrationBean myServletRegistration() {
		ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new MyServlet(),
		"/springboot/myServlet");
		return servletRegistrationBean;
	}
	@Bean
	public FilterRegistrationBean characterFilterRegistration() {
		//设置字符编码过滤器
		//CharacterEncoding 是由 Spring 提供的一个字符编码过滤器，之前是配置在web.xml 文件中
		CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
		//强制使用指定字符编码
		characterEncodingFilter.setForceEncoding(true);
		//设置指定字符编码
		characterEncodingFilter.setEncoding("UTF-8");
		//创建过滤器注册 bean
		FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
		//设置字符编码过滤器
		filterRegistrationBean.setFilter(characterEncodingFilter);
		//设置字符编码过滤器路径
		filterRegistrationBean.addUrlPatterns("/*");
		return filterRegistrationBean;
	}
}

#关闭 springboot 的 http 字符编码支持
#只有关闭该选项后，spring 字符编码过滤器才生效
spring.http.encoding.enabled=false

测试
无字符编码过滤器

使用字符编码过滤器

在 servlet 中添加 response.setContextType(“text/html;charset=utf-8”) 指定浏览器编码方式

配置文件（推荐使用）

主配置文件字符编码设置

#设置请求响应的字符编码
spring.http.encoding.enabled=true
spring.http.encoding.force=true
spring.http.encoding.charset=UTF-8

创建Servlet

public class MyServlet extends HttpServlet {
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		resp.getWriter().print("Hello World!世界您真好！");
		resp.setContentType("text/html;character=utf-8");
		resp.getWriter().flush();
		resp.getWriter().close();
	}
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		doGet(req, resp);
	}
}

创建配置类 ServletConfig

@Configuration
public class ServletConfig {
	@Bean
	public ServletRegistrationBean myServletRegistration() {
		ServletRegistrationBean servletRegistrationBean =new ServletRegistrationBean(new MyServlet(),"/myservlet");
		return servletRegistrationBean;
	}
}

测试
未添加字符编码设置

已添加字符编码设置

Springboot打包与部署

默认 SpingBoot 提供的打包插件版本为 2.2.2.RELEASE ，这个版本打的 jar 包包 jsp 不能访问，为我们这里修改为 1.4.2.RELEASE
（附：一般情况下javaweb项目部署）

war打包与部署

使用idea创建web项目时默认打成jar包，如果想打成war包，有两种方式：

创建时packaging 选择war，打包时会打成war包
pom.xml文件中有标签<packaging>jar</packaging>，将jar改成war，如果没有就加上<packaging>war</packaging>打成war包

打包插件maven在项目创建时自动添加，通过package指令把项目打包，生成的包在target目录下：项目名.war

部署：

如果项目中需要开启redis服务、mysql服务、zookeeper服务，要提前开启
将war放在Tomcat安装目录的webapp文件夹下，在bin目录下启动服务
在地址栏输入请求格式：IP地址:8080//war包名称/项目请求

jar打包与部署

项目创建时默认打jar包，在pom.xml文件中显示<packaging>jar</packaging>或者不显示项目都是默认打jar包
打包插件在项目创建时自动添加maven插件，可以通过maven的package指令打包项目
部署

如果项目中需要开启redis服务、mysql服务、zookeeper服务，要提前开启
将jar放在任意位置，在dos命令窗口切换到jar包所在文件目录，使用java -jar jar包包名即可运行程序
在地址栏输入请求格式（与war包请求不同的是，不需要添加包名在地址栏）：IP地址:8080//项目请求

springboot集成logback日志

pom.xml文件添加日志依赖lombok

<dependency>
 	<groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

安装日志插件
idea使用快捷键ctrl+alt+s 打开settings ，在Plugins的市场（Marketplace）搜索lombok，并进行安装，重启idea
日志配置文件logback-spring.xml
Spring Boot 官方推荐优先使用带有 -spring 的文件名作为你的日志配置。默认的命名规则，并且放在 src/main/resources 下如果你即想完全掌控日志配置，但又不想用 logback.xml 作为 Logback 配置的名字，application.properties可以通过 logging.config 属性指定自
定义的名字：

logging.config=classpath:logging-config.xml

logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
	<!-- 日志级别从低到高分为 TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如
	果设置为 WARN，则低于 WARN 的信息都不会输出 -->
	<!-- scan:当此属性设置为 true 时，配置文件如果发生改变，将会被重新加载，默认值为
	true -->
	<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默
	认单位是毫秒。当 scan 为 true 时，此属性生效。默认的时间间隔为 1 分钟。 -->
	<!-- debug:当此属性设置为 true 时，将打印出 logback 内部日志信息，实时查看
	logback 运行状态。默认值为 false。通常不打印 -->
	<configuration scan="true" scanPeriod="10 seconds">
	<!--输出到控制台-->
	<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
		<!--此日志 appender 是为开发使用，只配置最底级别，控制台输出的日志级别是
		大于或等于此级别的日志信息-->
		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
			<level>debug</level>
		</filter>
		<encoder>
			<Pattern>%date [%-5p] [%thread] %logger{60} [%file : %line] %msg%n</Pattern>
			<!-- 设置字符集 -->
			<charset>UTF-8</charset>
		</encoder>
	</appender>
	<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
		<!--<File>/home/log/stdout.log</File>-->
		<File>D:/log/stdout.log</File>
		<encoder>
			<pattern>%date [%-5p] %thread %logger{60} [%file : %line] %msg%n</pattern>
		</encoder>
		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
			<!-- 添加.gz 历史日志会启用压缩 大大缩小日志文件所占空间 -->
			<!--<fileNamePattern>/home/log/stdout.log.%d{yyyy-MM-
			dd}.log</fileNamePattern>-->
			<fileNamePattern>D:/log/stdout.log.%d{yyyy-MM-dd}.log</fileNamePattern>
			<maxHistory>30</maxHistory><!-- 保留 30 天日志 -->
		</rollingPolicy>
	</appender>
	<logger name="com.abc.springboot.mapper" level="DEBUG" />
	<root level="INFO">
		<appender-ref ref="CONSOLE"/>
		<appender-ref ref="FILE"/>
	</root>
</configuration>

在需要使用日志的类名上添加注解@Slf4j （一般针对 DAO 的包进行 DEBUG 日志设置），在方法中直接使用Logger对象log 显示info，error，warn，debug等信息：log.info(String);log.error(String);log.warn(String);log.debug(String)