导图社区 Springboot
Springboot 企业主流框架 maven、junit、集成mybaits 等学习 只分享培训干货。
编辑于2020-11-20 09:48:41Springboot
MAVEN安装和配置
Spring和springboot
springboot是对spring框架使用封装,目的是快速搭建spring环境,快速开发Spring应用
SpringBoot特点
SpringBoot完成采用java配置,去除xml配置模式
springBoot内置Tomcat等服务器,启动自动发布应用
springboot提供自动配置,创建连接池,jdbcTemplate等
springboot提供了大量启动工具包集合
springboot配置文件采用application.yml或application.properties
springboot程序可以采用jar包形式发布
spring-boot-starter 核心启动,自动配置,日志,yml的支持 spring-boot-starter-web SpringMVC restful tomcat spring-boot-starter-jdbc 连接池 数据库访问 spring-boot-starter-test JUnit单元测试工具
基于springmvc开发一个restful服务 /hello-->SpringMVC-->Hello World
创建maven project, 在pom.xml引入spring-boot-starter-web工具集
在src/main/respurces添加application.properties
server.port=8888
在src/main/java下定义RunBoot启动项
@SpringBootApplication//开启springboot功能 public class RunBoot { public static void main(String[] args) { //创建Spring容器,启动SpringBoot功能 SpringApplication.run(RunBoot.class); }
定义一个HelloController,映射/hello请求
@RestController //@Controller在spring容器创建对象+@ResponseBody把数据返回json public class HelloController { @RequestMapping("/hello") public String say(){ return "你他娘真是个人才"; }
启动RunBoot类运行Boot程序,打开浏览器访问
Spring-boot-devtools
加上只启动一次服务器就行(自动热部署)
基于Spring IOC容器创建一个DataSource连接池对象
创建maven project,在pom.xml引入spring-boot-starter-jdbc工具集
在src/main/resources添加application.properties
#datasource spring.datasource.username=system spring.datasource.password=123456 spring.datasource.url=jdbc:oracle:thin:@localhost:1521:XE #spring.datasource.driverClassName=
编写启动类,创建Spring容器,通过SpringBoot自动配置创建出dataSource和jdbcTemplate对象
@SpringBootApplication public class RunBoot { public static void main(String[] args) throws SQLException { ApplicationContext ac = SpringApplication.run(RunBoot.class, args); DataSource ds = ac.getBean("dataSource",DataSource.class); System.out.println(ds.getConnection()); JdbcTemplate template = ac.getBean("jdbcTemplate",JdbcTemplate.class); System.out.println(template); } }
SpringBoot容器
SpringBoot容器,其实就是对Spring容器封装。 原生Spring容器类型ApplicationContext,创建方法采用ClassPathXmlApplication加载applicationContext.xml配置。 SpringBoot容器类型ApplicationContext,创建方法采用SpringApplication.run(启动类.class)
2.加载打印启动Banner标识
3.根据程序类型创建出ApplicationContext对象
4.根据启动参数@SpringBootApplication向ApplicationContext添加组件和对象
5.启动程序,如果有Tomcat就启动Tomcat服务器,加载web应用
6.返回ApplicationContext对象
SpringApplication.run执行原理
1.判断SpringBoot程序类型,进行环境参数设置
@SpringBootApplication功能
@SpringBootApplication是一个复合标记,主要包含以下三个标记功能
1.@SpringBootConfiguration
Bean定义标记,功能等价于Spring的< bean id="" class="">。
实际上是对Spring中的@Configuration标记做的封装。
使用案例
@SpringBootConfiguration//开启bean定义功能 public class RunBoot { public static void main(String[] args) { ApplicationContext ac = SpringApplication.run(RunBoot.class, args); Object obj = ac.getBean("createMyDao"); System.out.println(obj); Object obj1 = ac.getBean("mydao"); System.out.println(obj1); Object obj2 = ac.getBean(MyDao.class); System.out.println(obj2); } @Bean//<bean id="createMyDao" class="cn.xdl.dao.MyDao"> //默认方法名做id public MyDao createMyDao() { MyDao dao = new MyDao(); return dao; } @Bean("mydao") @Primary//类型冲突时,作为默认使用对象 public MyDao createMyDao1() { MyDao dao = new MyDao(); return dao; } }
2.@ComponentScan
Bean扫描标记,功能等价于Spring的< context:component-scan base-package=""/>。
案例:
//@ComponentScan(basePackages={"cn.xdl.service"})//开启bean扫描功能,扫cn.xdl.service包组件 @ComponentScan//开启bean扫描功能,扫描当前包及子包中组件 public class RunBoot { public static void main(String[] args) { ApplicationContext ac = SpringApplication.run(RunBoot.class, args); Object obj = ac.getBean("createMyDao"); System.out.println(obj); Object obj1 = ac.getBean("mydao"); System.out.println(obj1); Object obj2 = ac.getBean(MyDao.class); System.out.println(obj2); Object obj3 = ac.getBean("myService"); System.out.println(obj3); } }
3.@EnableAutoConfiguration
Bean自动配置,是SpringBoot特有的,比如自动创建dataSource、jdbcTemplate对象等。
SpringBoot提供了大量自动配置组件,在@EnableAutoConfiguration开启自动配置后,会自动加载这些配置类,这些配置类创建各种对象。
本质:SpringBoot框架开发者提前写好了配置组件,配置组件使用了@Bean、@SpringBootConfiguration等Bean配置标记。
自动配置组件加载前提条件,必须有jar包,例如:
@ConditionalOnClass({ DataSource.class, JdbcTemplate.class }) @ConditionalOnSingleCandidate(DataSource.class)
必须存在才能创建
DataSource自动配置使用
SpringBoot提供了一个DataSourceAutoConfiguration自动配置组件,可以自动创建出DataSource对象。可以自动创建出下面类型的dataSource连接池
使用连接池自动配置组件操作过程:
开启自动配置@EnableAutoConfiguration/@SpringBootApplication
在pom.xml引入相关的jar包(spring-boot-starter-jdbc包含了hikari连接池)(ojdbc6驱动)
在application.properties或application.yml定义连接参数
yml:
spring: datasource: username: SCOTT password: TIGER url: jdbc:oracle:thin:@localhost:1521:XE
SpringBoot容器启动后,容器中就会产生id=dataSource名字的对象
Object obj=app.getBean("dataSource");
优先级创建
Hikari连接池对象
Tomcat连接池对象
dbcp2连接池对象
引入jar包 (spring-boot-starter-dbcp2)
type指定类型对象
指定创建类型连接池对象
想把某一个jar包里的工具排掉
加<exclusions>标记
在配置里追加一个参数 spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource
自定义dataSource
自定义阿里的连接池(导入jar包druid)
@Bean public DataSource druid() { DruidDataSource ds = new DruidDataSource(); ds.setUsername("system"); ds.setPassword("123456"); ds.setUrl("jdbc:oracle:thin:@localhost:1521:XE"); ds.setDriverClassName("oracle.jdbc.OracleDriver"); return ds; }
DateSource对象参数 不提倡写死 希望提取到配置里
参数的注入
在自动配置组件中,有一个ConfigurationPropertiesAutoConfiguration, 开启自动配置就可以使用@ConfigurationProperties标记将application.properties或application.yml配置文件中的参数给Spring容器中Bean对象属性注入。
子主题
application.yml配置信息
db: user: xdl password: 123
创建一个实体类 与配置名称对应并加标注
@ConfigurationProperties(prefix="db")//资源文件的配置 装载同名的参数 @Component//扫描 public class DbParams { private String user;//db.user private String password;//db.password //getset方法 }
第二种方式
自定义Bean对象,属性注入
ConfigurationProperties(prefix="db") @Bean public DbParams dbParams() { DbParams params = new DbParams(); return params; }
获取
Dbparams a=app.getBean("dbparams",Dbparams.class); System.out.println(a.getUser()+""+a.getPassword());
提示:必须开启自动配置才行@EnableAutoConfiguration,如果有个别属性与配置文件key不对应想注入参数,可以使用@Value单独定义。
@Value("${my.msg}") private String msg;//my.msg
@ConfigurationProperties(prefix="spring.datasource") @Bean public DataSource druid() { DruidDataSource ds = new DruidDataSource(); // ds.setUsername("system"); // ds.setPassword("123456"); // ds.setUrl("jdbc:oracle:thin:@localhost:1521:XE"); // ds.setDriverClassName("oracle.jdbc.OracleDriver"); return ds;
如果自定义了连接池,自动配置组件不会创建
Springboot数据访问
spring DAO jdbctemplate
在pom.xml定义引入spring-boot-startr-jdbc驱动包
在application.properties定义连接参数
编写一个启动类 开启@springbootApplication功能
ApplicationContext ac = SpringApplication.run(BootRun.class, args); AccountDao deptDao = ac.getBean("accountDaoImp",AccountDao.class); List<XdlBankAccount> list1 = deptDao.list(); for(XdlBankAccount dept:list1) { System.out.println(dept.getAcc_no()+" "+dept.getAcc_passwrod()+" "+dept.getAcc_money()); }
根据数据表编写实体类
编写dao接口和实现类,输入jdbctemplate使用
public List<XdlBankAccount> list() {//实现类 String sql = "select * from xdl_bank_account"; RowMapper<XdlBankAccount> rowMapper = new BeanPropertyRowMapper<XdlBankAccount>(XdlBankAccount.class); List<XdlBankAccount> list = template.query(sql, rowMapper); return list; }
Springboot + mybatis(标注版)
在pom,xml定义引入spring-boot-starter-jdbc,驱动包,mybatis-spring-boot-starter
mybatis-spring-boot-starter分页插件
在application.properties定义连接参数
#datasource spring.datasource.username=system spring.datasource.password=123456 spring.datasource.url=jdbc:oracle:thin:@localhost:1521:XE #pring.datasource.type=org.apache.commons.dbcp2.BasicDataSource #spring.datasource.driverClassName= #mybatis.mapper-locations=classpath:sql/*.xml
编写一个启动类 开启@springbootApplication功能
@SpringBootApplication @MapperScan(basePackages={"cn.xdl.dao"})//扫描Mybatis的Mapper接口 public class RunBoot { public static void main(String[] args) { ApplicationContext app= SpringApplication.run(RunBoot.class); XdlBankAccountDao xdl=app.getBean("xdlBankAccountDao",XdlBankAccountDao.class); List<XdlBankAccount> list=xdl.list(); for (XdlBankAccount xdlBankAccount : list) { System.out.println(xdlBankAccount.getAcc_no()+""+xdlBankAccount.getAcc_passwrod()+""+xdlBankAccount.getAcc_money()); } } }
根据数据表编写实体类(名称与字段保持一致)
编写接口,利用标注定义sql语句
public interface XdlBankAccountDao { @Select("select * from xdl_bank_account") List<XdlBankAccount> list(); @Select("select * from xdl_bank_account where id=#{acc_no} and acc_password=#{acc_password}") XdlBankAccount login(@Param("acc_no") String acc_no,@Param("acc_password") String acc_password); }
spring JPA
java persistence api java持久化api,Hibernate是 jpa典型实现.
特点:通过对象操作就能实现对数据表操作
在pom,xml定义引入spring-boot-starter-jdbc,驱动包,spring-boot-starter-jpa
在application.properties定义连接参数
编写一个启动类 开启@springbootApplication功能
@SpringBootApplication public class BootRun { public static void main(String[] args) { ApplicationContext app =SpringApplication.run(BootRun.class); AccountDao acc=app.getBean("accountDao",AccountDao.class); List<Dept> list = acc.findAll(); for (Dept xdlBankAccount : list) { System.out.println(xdlBankAccount.getDname()); } } }
根据数据表编写实体类(定义与表映射关系)
@Entity//代表这是一个实体 @Table(name="DEPT")//和哪个表对应 public class Dept { @Id//主键 @Column(name="DEPTNO")//和哪个字段对应 private Integer deptno; @Column(name="DNAME") private String dname; @Column(name="LOC") private String loc;
编写dao接口 继承jpa父接口
JpaRepository/PagingAndSortingRepository/CrudRepository/Repository
//实体类 //主键ID类型 public interface AccountDao extends JpaRepository<Dept, Integer> {
排序 分页
Sort sort=new Sort(Direction.DESC,"deptno");//降序 Pageable page=PageRequest.of(0, 2,sort);//第几页 从0开始, 显示几条 Page<Dept> list = acc.findAll(page);//返回Page 类似list ...foreach System.out.println("总页数"+list.getTotalPages());
在application.properties配置分页方言
spring.jpa.show-sql=true spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.OracleDialect
其他字段查询
方法一:
在dao接口中定义 定义需要按照规则如:
//通过一个name查询数据 public Dept findByDname(String name); //通过模糊查询查找数据 public List<Dept> findByDnameLike(String name); //通过名字和所在地查询数据 public Dept findByDnameAndLoc(String name,String loc); //查询大于参数的数据 public List<Dept> findByDeptnoGreaterThan(int no);
方法二:
在接口中
@Query(nativeQuery=true//表示执行原始sql语句,value="select * from dept where deptno=:id")//执行指定的SQL语句 public Dept findSQL(@Param("id")int no);
Springboot MVC
开发web服务(Restful服务)
创建maven project,在pom.xml中映入spring-boot-starter-web ojdbc、mybatis-spring-boot-starter、spring-boot-starter-jdbc 分页pagehelper-spring-boot-starter spring-boot-starter-test 测试spring-boot-devtools(post)
在application。properties定义参数(server,datasource)
server.port=8888 spring.datasource.username=system spring.datasource.password=123456 spring.datasource.url=jdbc:oracle:thin:@localhost:1521:XE
根据表定义实体类
编写一个启动类RunBoot, 添加@SpirngBootApplication//开启springBoot功能 @MapperScan(basePackages={"cn.xdl.dao"})//扫描Mybatis的Mapper接口
扩展:定义Mapper接口和注解SQL
@Select("select * from students") public List<Students> selectAll();
创建业务层Service接口并实现
public List<Students> loadList(int page,int size);
@Service public class DeptServiceImpl implements DeptService { @Autowired//Mapper接口注入 private DeptMapper deptDao; public List<Students> loadList(int page, int size) { PageHelper.startPage(page, size);//分页 List<Students> list = deptDao.selectAll(); return list; }
编写一个控制层Controller
@RestController//@Controller在spring容器创建对象+@ResponseBody把数据返回json public class DeptController { @Autowired//Service接口注入 private DeptService deptService; @GetMapping("/dept/fengye") public List<Students> list3( @RequestParam(value="page",required=false,defaultValue="1")int page, @RequestParam(value="size",required=false,defaultValue="3")int size){ return deptService.loadList(page, size);
测试
开发网页程序(HTML界面)
SpringBoot集成了Thymeleaf模板技术,可以替代JSP生成HTML响应界面。 SpringBoot推荐使用模板技术。
模板技术有点: 简单、易用 基于缓存、效率高
模板技术在使用中重点:编写模板文件+模板表达式语言
Freemarker hello.ftl + FTL Velocity hello.vm + VTL
Thymeleaf THTL
Thymeleaf模板文件放在 src/main/resources/templates目录下
<html xmlns:th="http://www.thymeleaf.org">
THTL表达有 th:text 赋值、字符串拼接 th:each for 循环 th:href URL th:if 条件判断
步骤:
创建maven project,在pom.xm.l中引入web thymeleaf
在application.properties配置 server.port端口
编写一个启动类RunBoot,定义@SpringBootApplication
定义编写HelloController 返回ModelAdnView
@Controller public class HelloController { @Autowired private StudentsDao studentsdao; @GetMapping("/Hello") public ModelAndView say() { ModelAndView mav = new ModelAndView(); mav.getModel().put("msg","Hello Thymeleaf"); List<Students> students =studentsdao.findAll(); mav.getModel().put("Studentss", students); mav.setViewName("hello");//templates/hello.html return mav; } @GetMapping("/delete") public String del(int id){ studentsdao.deleteById(id); return "redirect:/Hello"; }
在src/mian/resources/templates下定义hello.html
<h1 th:text="${msg}" ></h1> <table> <tr th:each="dept : ${Studentss}"> <td th:text="${dept.id}"></td> <td th:text="${dept.name}"></td> <td th:text="${dept.password}"></td> <td><a th:href="@{/delete(id=${dept.id})}">删除</a></td> </tr> </table>
springboot jsp页面
<!--spring-Boot导入支持JSP页面的 2个必须依赖包--> <dependency>--jsp标签库 <groupId>jstl</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> <dependency> Tomcat JSP解析引擎支持 --> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <version>8.5.29</version> </dependency>
resources配置文件
#返回的前缀 目录对应src/main/webapp下 spring.mvc.view.prefix=/WEB-INF/jsp/ #返回的后缀 spring.mvc.view.suffix=.jsp
JUnit测试mvc
MockMvc
发送请求接受请求结果
@RunWith(SpringRunner.class) @SpringBootTest(classes= {RunBoot.class}) public class TestHelloController { @Autowired private HelloController controller;
//创建mockmvc MockMvc mockmvc=MockMvcBuilders.standaloneSetup(controller).build();
//创建请求 RequestBuilder request=MockMvcRequestBuilders.get(“/Hello”);
如果获取post请求
改成post
@postMapping
//添加參數 .param()
如: .param("name", "ljq").param("password", "123");
//发送请求,获取返回结果MvcResuit MvcResult result = mockmvc.perform(request).andReturn();
//获取返回结果内容显示到控制台 System.out.println(result.getResponse().getContentAsString());
SpringBoot MVC 异常处理
原有Spring MVC异常处理经常采用:@ExceptionHandler和SimpleMappingExceptionResolver。 SpringBoot MVC异常处理经常采用自动配置ErrorMvcAutoConfiguration和@ExceptionHandler。
ErrorMvcAutoConfiguration工作原理
开启自动配置后,会自动加载ErrorMvcAutoConfiguration,该组件会自动创建一个BasicErrorController,提供两个/error请求响应处理,一个返回HTML结果,另一个返回JSON结果。 当执行SpringBootMVC处理过程中,抛出异常,SpringBoot会自动转发/error请求处理,用户就看到默认的一个白板页面或JSON结果。
@ExceptionHandler使用方法
在Controller中定义异常处理方法,追加@ExceptionHandler注解,参数必须有个Exception
界面响应: @ExceptionHandler public ModelAndView handleException(Exception ex) { ModelAndView mav = new ModelAndView(); mav.setViewName("myerror");//myerror.jsp return mav; }
JSON响应: @ExceptionHandler @ResponseBody public Map handleException(Exception ex) { Map data = new HashMap<String, Object>(); data.put("msg", "发生异常"); data.put("type", ex.getClass().getName()); return data; }
BasicErrorController使用方法
BasicErrorController能捕获不存在的请求异常,如果存在但是没有定义@ExceptionHandler也会调用BasicErrorController处理。能处理整个程序级别的异常。 程序员可以自定义ErrorController替代BasicErrorController组件,这样可以定位到自己的页面或按自己定义格式输出JSON。
提示:启动后通过组件扫描进入Spring容器,自定义ErrorMvcAutoConfiguration组件就会失效,不会创建BasicErrorController。
步骤:
新建MyErrorController 控制器 实现ErrorController 从写getErrorPath 返回 /error
@RequestMapping("/error") public ModelAndView error() { ModelAndView mav = new ModelAndView(); mav.setViewName("error"); return mav; }
界面响应
创建异常页面
@RequestMapping("/error") @ResponseBody public Map errorJson() { Map<String, Object> data = new HashMap<String, Object>(); data.put("msg", "发生异常"); return data; }
json响应
Springboot拦截器
编写拦截器类,按规则实现HandlerInterceptor接口
@Component public class MyInterceptor implements HandlerInterceptor{ public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { System.out.println("Controller执行之前调用preHandle"); return true;//表示通过,允许继续执行调用Controller } public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,@Nullable ModelAndView modelAndView) throws Exception { System.out.println("Controller执行之后调用postHandle"); } public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,@Nullable Exception ex) throws Exception { System.out.println("响应输出之前调用afterCompletion"); } }
编写配置类,按规则实现WebMvcConfigurer接口
@Component public class MyInterceptorConfiguration implements WebMvcConfigurer{ @Autowired //拦截类 private MyInterceptor my; public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(my).addPathPatterns("/m2"); } }
SpringBoot Servlet
在SpringBoot中使用Servlet、Filter、Listener组件,可以使用@ServletComponentScan、@WebServlet、@WebFilter、@WebListener等。
Servlet示例
按原有规则编写Servlet实现类,继承HttpServlet
@WebServlet(name="helloSerlvet",urlPatterns= {"/hello","/hello.do"}) public class HelloServlet extends HttpServlet{ public void service(HttpServletRequest request,HttpServletResponse response) throws IOException { response.setContentType("text/html;charset=UTF-8"); PrintWriter out = response.getWriter(); out.print("Hello Servlet"); out.close(); } }
使用@ServletComponentScan和@WebFilter配置
@SpringBootApplication @ServletComponentScan//扫描Servlet、Filter、Listener组件 public class RunBoot { public static void main(String[] args) { SpringApplication.run(RunBoot.class, args); } }
Filter 示例
//@WebFilter(urlPatterns= {"/hello","/hello.do"},filterName="myfilter1") @WebFilter(servletNames= {"helloSerlvet"}) public class MyFilter1 implements Filter{ public void init(FilterConfig filterConfig) throws ServletException { // TODO Auto-generated method stub } public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { System.out.println("执行MyFilter1处理"); chain.doFilter(request, response); } public void destroy() { // TODO Auto-generated method stub } }
提示:多个Filter执行顺序按类名字典排序执行。
图片文件名称约定
优先级 resources-static-public
SpringBoot task schedule定时任务
服务器启动后立刻执行某个任务处理
springboot提供了两个接口,编写实现类接口就可以实现服务器启动后的效果
可以使用@Older(1,2,3....) 定义多个任务的顺序
ApplicationRunner接口
@Component @Order(2)//指定任务执行顺序 多个任务单线程 public class MyTask implements ApplicationRunner{ public void run(ApplicationArguments args) throws Exception { System.out.println("hello"); }
CommandLineRunner接口
@Controller @Order(1) public class MyTask2 implements CommandLineRunner{ public void run(String... args) throws Exception { System.out.println("hello2"); }
在一个线程执行
服务器启动后按指定时间或周期执行任务处理
springboot采用springSchedule模块完成,也可以使用第三方的quartz完成
@Controller @EnableScheduling //启动spring Schedule模块 public class MyTask3 { @Scheduled(cron="0/1 * * * * ?")//启动后过1秒执行,执行的周期5秒 //@Scheduled(initialDelay=1000,fixedRate=5000)//启动后过1秒执行,执行周期5秒 public void run(){ System.out.println(new Date()); }
Cron表达式规则
秒 分 时 日 月 星期 年 0/5 * * * * ? * 可以用在任意位置,表示任意数值,表示每分钟、每小时,每一天等 ? 只能用在日和星期两个位置,用于解决冲突问题。如果指定日,星期用?;如果指定了星期,日用? / 表示增量,比如0/5,表示0、5、10、15、20、25...;3/5,表示3、8、13、18、23、28...
搭建私服
有一些jar包引入需要网络 本地-教师机-网络
阿里云远程库
<mirror> <id>nexus</id> <mirrorOf>*</mirrorOf> <url>http://maven.aliyun.com/nexus/content/groups/public/</url> </mirror> </mirrors>
JUnit单元测试
用于测试某个功能或者某个功能处理,java一般使用junit工具做单元测试
junit工具
@Test
每个带有@Test的标注 都会做为单独的线程来执行
@Before
在@Test之前每次执行
@After
在@Test之后每次执行
断言
Assert.assertEquals(期望值,实际值)
第一种方式
public class TestDeptDao { DeptDao deptDao; ApplicationContext ac; @Before public void mybefore() { ac = SpringApplication.run(RunBoot.class); deptDao = ac.getBean("deptDao",DeptDao.class);} @After public void myAfter() { ac = null; deptDao = null; } @Test public void test1() { 直接测试 }
第二种方式
引入包spring-boot-starter-test
@RunWith(SpringRunner.class) // 启动junit,并实例化spring容器对象 @SpringBootTest(classes = { BootRun.class }) // 指定启动类 public class testDemo(){ @Autowired// 注入测试对象 private AccountDao accountdao;
jar包发布
1.在pom.xml引入maven-plugin插件(打包)
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
2.选中工程Run As-->maven install/maven build... (package)-->自动在target目录下生成jar包
3.放到服务器执行java -jar xxx.jar运行
new StopWatch() 可以看执行时间
start()开始
stop()结束
getTotalTimeMillis()总共花费的时间