Springboot

关于springboot:SpringBoot-整合-RabbitMQ

筹备1.新建springboot我的项目2.增加Spring for Rabbitmq依赖3.yml中配置rabbitmq信息: spring: rabbitmq: host: 192.168.64.140 username: admin password: admin每个模式创立一个包,包中蕴含主程序(main办法),生产者,消费者,每测试一个程序启动一个main办法即可. 简略模式主程序@SpringBootApplicationpublic class Main { @Autowired private Producer p; public static void main(String[] args) { SpringApplication.run(Main.class,args); } /* springboot我的项目残缺启动实现以后对象中须要注入的对象注入实现之后才会执行该办法 */ @PostConstruct public void test(){ p.send(); } /* 封装队列参数的对象 RabbitAutoConfiguraion 主动配置类,会主动发现Queue 在服务器上定义该队列 */ @Bean public Queue helloworldQueue(){ //return new Queue("helloworld");//true,false,false 长久,非独占,非主动删除 return new Queue("helloworld",false); }}生产者@Componentpublic class Producer { /* AmqpTemplate的实例是在 RabbitmqAutoConfiguration主动配置类中创立的 */ @Autowired private AmqpTemplate t; public void send(){ t.convertAndSend("helloworld", "Hello World!"); }}消费者@Componentpublic class Consumer { /* 消费者主动注册,主动连贯服务器,主动开启音讯监听 */ @RabbitListener(queues = "helloworld") public void receive(String msg){ System.out.println("收到:"+msg); }}工作模式工作模式还须要实现两点:1.正当散发:手动ack:springboot整合rabbitmq默认手动ack,并且主动返回回执qos=1:yml中配置:spring.rabbitmq.listener.simple.prefetch:12.长久化:队列长久化/音讯长久化:springboot整合rabbitmq中都是默认长久的若是不想要其长久 --> ...

关于springboot:SpringBoot打包时分离ymlpropertiesxml配置文件以及依赖包

1.批改pom文件：<output.dependence.file.path>lib/</output.dependence.file.path><output.resource.file.path>resource/</output.resource.file.path><build> <resources> <resource> <directory>src/main/resources</directory> <excludes> <exclude>*.properties</exclude> <exclude>*.yml</exclude> </excludes> </resource> </resources> <plugins>  <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-jar-plugin</artifactId> <configuration>  <excludes> <exclude>*.**</exclude> <exclude>*/*.xml</exclude> <exclude>*.properties</exclude> <exclude>*.yml</exclude> <exclude>*/*.properties</exclude> <exclude>*/*.yml</exclude> </excludes> <archive> <manifest>  <addClasspath>true</addClasspath>   <classpathPrefix>lib/</classpathPrefix>  <useUniqueVersions>false</useUniqueVersions>  <mainClass>com.htcs.modules.WebApplication</mainClass> </manifest> <manifestEntries>   <Class-Path>./resources/</Class-Path> </manifestEntries> </archive> <outputDirectory>${project.build.directory}</outputDirectory> </configuration> </plugin>  <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-dependency-plugin</artifactId> <executions> <execution> <id>copy-dependencies</id> <phase>package</phase> <goals> <goal>copy-dependencies</goal> </goals> <configuration> <outputDirectory> ${project.build.directory}/lib/ </outputDirectory> </configuration> </execution> </executions> </plugin>  <plugin> <artifactId>maven-resources-plugin</artifactId> <executions> <execution> <id>copy-resources</id> <phase>package</phase> <goals> <goal>copy-resources</goal> </goals> <configuration> <resources> <resource> <directory>src/main/resources</directory> <includes> <include>*.properties</include> <include>*.yml</include> <include>*/*.properties</include> <include>*/*.properties</include> </includes> </resource> </resources> <outputDirectory>${project.build.directory}/resources</outputDirectory> </configuration> </execution> </executions> </plugin>  <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration>  <includes> <include> <groupId>non-exists</groupId> <artifactId>non-exists</artifactId> </include> </includes> <layout>ZIP</layout>  <addResources>true</addResources> <outputDirectory>${project.build.directory}</outputDirectory> </configuration> <executions> <execution> <goals> <goal>repackage</goal> </goals> <configuration>    </configuration> </execution> </executions> </plugin> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <version>2.22.2</version> <configuration> <skipTests>true</skipTests> </configuration> </plugin> </plugins></build>2.执行打包maven命令mvn package3.拷贝相应文件到服务器 ...

关于springboot:IDEA创建Spring-Boot项目无法连接httpstartspringio-解决方法

给本人做的一个记录敞开防火墙换网络批改Auto-detect proxy settings等在Custom中https改为http还是Custom，试了 https://start.springboot.io,但还是不稳固，最初还是http://start.aliyun.com胜利解决，但版本不是最先进的

关于springboot:第七天代码

pojo层层层层层层@Datapublic class Activity { private Integer id; private String title; private String category; //@DateTimeFormat 作用于set办法示意为属性赋值，基于什么日期格局执行 @DateTimeFormat(pattern = "yyyy/MM/dd HH:mm") //@JsonFormat 用于通知spring mvc 转换json时,将日期依照指定格局进行转换. //@JsonFormat 作用于对象get办法，示意获取值时的一种格局 @JsonFormat(pattern = "yyyy/MM/dd HH:mm",timezone = "GMT+8") private Date startTime; @DateTimeFormat(pattern = "yyyy/MM/dd HH:mm") @JsonFormat(pattern = "yyyy/MM/dd HH:mm",timezone = "GMT+8") private Date endTime; private String remark; private Integer state=1; @JsonFormat(pattern = "yyyy/MM/dd HH:mm",timezone = "GMT+8") private Date createdTime; private String createdUser;}dao 层层层层层@Mapperpublic interface ActivityDao { /** * 批改流动信息状态,将其设置为已完结状态0; * @param id * @return */ @Update("update tb_activity set state=0 where id=#{id}") int updateState(Integer id); /** * 增加流动信息 * @param entity * @return */ int insertObject(Activity entity); /** * 获取所有流动信息,一行记录映射为一个Activity对象(row map-行映射) * @return */ @Select("SELECT * FROM tb_activity order by createdTime desc") List<Activity> findActivitys();}service 层层层层层package com.cy.pj.activity.service;import java.util.List;import com.cy.pj.activity.pojo.Activity;public interface ActivityService { int saveObject(Activity entity); List<Activity> findActivitys();}service imp实现层实现层实现层实现层实现层@Servicepublic class ActivityServiceImpl implements ActivityService { @Autowired private ActivityDao activityDao; @Override public int saveObject(Activity entity) { // TODO Auto-generated method stub //System.out.println("entity.insert.before.id="+entity.getId()); int rows=activityDao.insertObject(entity);//System.out.println("entity.insert.after.id="+entity.getId()); //心愿工夫到了(endTime)主动批改活动状态 //解决方案:基于任务调度去实现(任务调度-基于工夫的设计主动执行工作) //代码计划: //1)借助Java中的Timer对象去实现 Timer timer=new Timer();//此对象创立时会在底层启动一个线程,通过此线程对工夫进行监控 //2)执行工作(工作类型为TimerTask类型) timer.schedule(new TimerTask() { @Override public void run() { //在此地位批改流动的状态信息 System.out.println("开始执行活动状态的批改操作"); activityDao.updateState(entity.getId()); timer.cancel(); } }, entity.getEndTime()); //2)借助Java线程池中的任务调度对象(ScheduledExecutorService )去实现 //3)借助第三方框架去实现(quartz) return rows; } @Override public List<Activity> findActivitys() { //未来要进行缓存设计,记录日志,.... return activityDao.findActivitys(); }}Controller 层层层层层@Controller@RequestMapping("/activity/")public class ActivityController { @Autowired private ActivityService activityService; /** * 基于此办法返回activity页面 * @return */ @RequestMapping("doActivityUI") public String doActivityUI() { return "activity"; } @RequestMapping("doSaveObject") @ResponseBody public String doSaveObject(Activity entity) { System.out.println(entity);//如果心愿这样查看对象内容,则须要重写对象的toString办法 activityService.saveObject(entity); //return "activity";//这样返回，刷新的是整个页面 System.out.println("ABCD"); return "save ok"; } @RequestMapping("doFindActivitys") @ResponseBody //通知spring 框架将返回值对象转换为json格局字符串 public List<Activity> doFindActivitys()throws Exception{ // Thread.sleep(5000); List<Activity> list=activityService.findActivitys(); return list; }}xml 配置文件。。。<mapper namespace="com.cy.pj.activity.dao.ActivityDao">  <insert id="insertObject" parameterType="com.cy.pj.activity.pojo.Activity" useGeneratedKeys="true" keyProperty="id"> insert into tb_activity (title,category,startTime,endTime,remark,state,createdTime,createdUser) values (#{title},#{category},#{startTime},#{endTime},#{remark},1,now(),#{createdUser}) </insert></mapper>html 文件配置代码<!DOCTYPE html><html><head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Insert title here</title><link href="/bootstrap/css/bootstrap.min.css" rel="stylesheet"><link href="/datepicker/css/bootstrap-datetimepicker.min.css" rel="stylesheet"></head><body> <div class="container"> <h1>The Activity Page</h1>  <button type="button" class="btn btn-primary" data-toggle="modal" data-target="#myModal">创立新流动</button>  <div class="modal fade" id="myModal" tabindex="-1" role="dialog" aria-labelledby="myModalLabel"> <div class="modal-dialog" role="document"> <div class="modal-content"> <div class="modal-header"> <button type="button" class="close" data-dismiss="modal" aria-label="Close"> <span aria-hidden="true">×</span> </button> <h4 class="modal-title" id="myModalLabel">增加流动</h4> </div> <div class="modal-body"> <form id="saveFormId" action="/activity/doSaveObject" method="post"> <div class="form-group"> <label for="titleId">title</label> <input type="text" class="form-control" name="title" id="titleId" placeholder="please input title"> </div> <div class="form-group"> <label for="cagegoryId">Category</label> <select class="form-control" name="category" id="categoryId"> <option value="training">教育培训</option> <option value="Playing">企业流动</option> </select> </div> <div class="form-group"> <label for="startTimeId">start time</label> <input type="text" class="form-control form_datetime" name="startTime" id="startTimeId" placeholder="please input startTime" autocomplete="off"> </div> <div class="form-group"> <label for="endTimeId">end time</label> <input type="text" class="form-control form_datetime" name="endTime" id="endTimeId" placeholder="please input end time" autocomplete="off"> </div> <div class="form-group"> <label for="remarkId">Remark</label> <textarea class="form-control" name="remark" id="remarkId"></textarea> </div> </form> </div> <div class="modal-footer"> <button type="button" class="btn btn-default" data-dismiss="modal">Close</button> <button type="button" class="btn btn-primary" onclick="doSaveObject()">Save changes</button> </div> </div> </div> </div> <table class="table"> <thead> <tr> <th>id</th> <th>title</th> <th>category</th> <th>start time</th> <th>end time</th> <th>state</th> <th>createdTime</th> </tr> </thead> <tbody id="tbodyId"> <tr> <td colspan="7">数据正在踊跃的加载中......</td> </tr> </tbody> </table> </div> <script type="text/javascript" src="/jquery/jquery.min.js"></script>  <script src="/bootstrap/js/bootstrap.min.js"></script> <script src="/datepicker/js/bootstrap-datetimepicker.min.js"></script> <script src="/datepicker/js/locales/bootstrap-datetimepicker.zh-CN.js"></script> <script type="text/javascript"> //在指定地位初始化datepicker对象 $(".form_datetime").datetimepicker({ language:'zh-CN', format:'yyyy/mm/dd hh:ii', autoclose:true }) //提交form表单,执行save操作 function doSaveObject(){ //基于此形式提交表单，表单中的元素肯定要有name属性， //并且name属性名的设计肯定要于服务端接管参数时的设计相匹配 //$("#saveFormId").submit();//同步提交 //======================================= //1.定义url let url="/activity/doSaveObject"; //2.定义申请参数 /* var params={ title:$("#titleId").val(),//val()为jquery中或指定表单元素的value值 category:$("#categoryId").val(), startTime:$("#startTimeId").val(), endTime:$("#endTimeId").val(), remark:$("#remarkId").val() } */ //debugger var params=$("#saveFormId").serialize();//serialize()为jquery中间接获取表单数据办法 console.log("params",params);//验证参数的值吗 //3.发送异步申请 $.ajax({ type:"post", url:url, data:params, success:function(result){ alert(result); //暗藏模态框 $('#myModal').modal('hide'); //从新执行查问，部分刷新 findActivitys(); } }); } //向服务端发送异步申请获取流动信息并更新到页面上 function findActivitys(){ //debugger //此单词写的地位很重要(这是入口),你要对谁进行断点剖析. let url="/activity/doFindActivitys"; let params={}; //借助jquery中的ajax函数,向服务端发送异步申请获取流动信息 $.ajax({//具体格局官网有定义(如果不想看官网,看现成第三方网站找ajax) url:url, data:params, dataType:"json", success:function(result){ doHandleQueryResult(result); } }); }; //解决服务端返回的流动信息,迭代result,并将result内容填充tbody地位 function doHandleQueryResult(result){ ///debugger console.log(result) //1.获取tbody对象,并清空原有内容 var tBody=$("#tbodyId");//原生写法-document.querySelector("#tbodyId") tBody.empty();//清空tbody中原有内容 //2.迭代result,将流动信息追加到tbody中 result.forEach((item)=>{//这里的item为一个变量,代表数组中某一个元素 //debugger tBody.append( `<tr> <td>${item.id}</td> <td>${item.title}</td> <td>${item.category}</td> <td>${item.startTime}</td> <td>${item.endTime}</td> <td>${item.state==1?'无效':'已完结'}</td> <td>${item.createdTime}</td> </tr>` ); }); } //jquery中定义的页面加载残缺执行形式如下: // $(function(){//如果所有的js代码放到html页面的head标签,倡议这样写 findActivitys(); //});//页面加载实现当前执行 </script></body></html>配置文件服务器#serverserver.port=80server.servlet.context-path=/# spring datasourcespring.datasource.url=jdbc:mysql:///dbactivity?serverTimezone=GMT%2B8&characterEncoding=utf8spring.datasource.username=rootspring.datasource.password=root# spring mybatismybatis.mapper-locations=classpath:/mapper/*/*.xml# spring thymleafspring.thymeleaf.cache=falsespring.thymeleaf.prefix=classpath:/templates/modules/#spring.thymeleaf.suffix=.html# loglogging.level.com.cy=debug

关于springboot:第六天的代码

ajaxController层层层层层@Controller@RequestMapping("/")public class AjaxController { private List<String> container=new ArrayList<>(); @RequestMapping("doCheck") @ResponseBody public String doCheck(String name) { if(container.contains(name)) return name+"已存在,请换个名字"; return name +"不存在,能够注册"; } @RequestMapping("doSave") @ResponseBody public String doSave(String name) {//办法参数名和客户端申请参数名雷同 container.add(name);//后续这个值能够存储到数据库 return name+" save ok"; } @RequestMapping("doAjaxGet") @ResponseBody //通知spring mvc 此办法的返回值不是viewname,能够将其看成是一般字符串 public String doAjaxGet()throws Exception { //Thread.sleep(5000); return "Ajax Get Request Result"; }}Controller 层层层层层@Controller@RequestMapping("/jquery/")public class JQueryController { @RequestMapping("doAjaxGet") @ResponseBody public String doAjaxGet(String msg) { if(Math.random()>0.1) { throw new IllegalArgumentException("参数异样"); } //将客户端传到服务端的字符换转换为大写,而后再响应给客户端. return "Jquery Get request result "+msg.toUpperCase(); } @RequestMapping("doAjaxPost") @ResponseBody public String doAjaxPost(Integer id,String title) { //将客户端传到服务端的字符换转换为大写,而后再响应给客户端. return "Jquery Post request result "+id+"/"+title; } @RequestMapping("doAxiosPost") @ResponseBody public String doAxiosPost(@RequestBody Message msg) { return msg.toString(); }}Message controller pojo层层层public class Message { private Integer id; private String title; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } @Override public String toString() { return "Message [id=" + id + ", title=" + title + "]"; }}ajax-01<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title></head><body> <h1>The Ajax-01 Page</h1> <fieldset> <legend>Ajax 异步申请</legend> <button onclick="doAjaxGet()">Ajax Get Request</button> <span id="ajaxResultId">The Data is Loading ....</span> </fieldset> <script type="text/javascript"> //JS中代码调试技巧:3种办法(日志-console.log(),断点-debugger,排除法) function doAjaxGet(){ // debugger (只有在关上控制台窗口当前才无效) //1.创立xhr对象 var xhr=new XMLHttpRequest(); //2.设置xhr对象的事件监听函数 xhr.onreadystatechange=function(){ console.log(xhr.readyState); //readyState==4示意服务端的响应后果在客户端曾经接管完了 //status==200示意服务解决申请的过程中没有呈现任何异样.(响应的都是失常数据) if(xhr.readyState==4&&xhr.status==200){ //获取span对象 var span=document.getElementById("ajaxResultId"); //更新span对象外部的内容 span.innerHTML=xhr.responseText; } }; //3.建设连贯(Get申请形式) xhr.open("GET","http://localhost/doAjaxGet",true);//true示意异步 //4.发送申请 xhr.send(null); //console.log("======main======"); } </script></body></html>ajax-02<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title></head><body> <h1>The Ajax 02 Page</h1> <fieldset> <legend>Ajax 表单申请</legend> <form> <input type="text" id="nameId" name="name" onblur="doCheck()" onfocus="doClear()"> <input type="button" onclick="doSave()" value="Save"> </form> <span id="resultId"></span> </fieldset> <script type="text/javascript"> function doClear(){ document.forms[0].name.value=""; document.getElementById("resultId").innerHTML=""; } //检测名字是否已存在 function doCheck(){ //1.创立XHR对象 const xhr=new XMLHttpRequest(); //2.定义XHR对象的状态监听函数 xhr.onreadystatechange=function(){ if(xhr.readyState==4&&xhr.status==200){ document.getElementById("resultId").innerHTML= `<font color='red'>${xhr.responseText}</font>`; } } //3.建设连贯 let name=document.forms[0].name.value; xhr.open("GET",`doCheck?name=${name}`,true); //4.发送申请 xhr.send(null); } //保留表单中名字的值 function doSave(){//debugger,log,排除法 // debugger //1.创立XHR对象 const xhr=new XMLHttpRequest(); //2.定义XHR对象的状态监听函数 xhr.onreadystatechange=function(){ if(xhr.readyState==4&&xhr.status==200){ document.getElementById("resultId").innerHTML=xhr.responseText; } } //3.建设连贯(Post) xhr.open("POST","doSave",true); //post申请传参须要设置申请头 xhr.setRequestHeader("Content-Type","application/x-www-form-urlencoded"); //4.发送申请 let name=document.forms[0].name.value;//获取输出的name属性值 //构建参数对象 //4.1形式1 //var params="name="+name;//淘汰 //4.2形式2 const params=`name=${name}`;//一种新的写法,这种写法称之为模板字符串,所有字符串拼接都能够以这种形式进行实现 //4.3形式3 //var params={"name":name};//JavaScript中的对象(原生ajax形式默认不能够间接传递这样的对象) xhr.send(params);//post申请的参数须要写到此地位 } </script></body></html>ajax-03<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title></head><body> <h1>The Ajax 03 Page</h1> <fieldset> <legend>Ajax 表单申请</legend> <form> <input type="text" id="nameId" name="name" onblur="doCheck()"> <input type="button" onclick="doSave()" value="Save"> </form> <span id="resultId"></span> </fieldset> <script type="text/javascript" src="/js/ajax.js"></script> <script type="text/javascript"> //检测名字是否已存在 function doCheck(){ //1.定义申请的url var url="http://localhost/doCheck"; //2.定义申请参数 var name=document.forms[0].name.value; var params=`name=${name}`; //3.发送ajax get申请 doAjaxGet(url,params,(result)=>{ document.getElementById("resultId").innerHTML= `<font color=red>${result}</font>`; }); } //保留表单中名字的值 function doSave(){//debugger,log,排除法 //1.申请url const url="http://localhost/doSave"; //2.申请参数 let name=document.forms[0].name.value; let params=`name=${name}`; //3.发送ajax post申请 doAjaxPost(url,params,(result)=>{ alert(result); }) } </script></body></html>ajax-04<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title></head><body> <h1>The Ajax 04 Page</h1> <fieldset> <legend>Ajax 表单申请</legend> <form> <input type="text" id="nameId" name="name" onblur="doCheck()"> <input type="button" onclick="doSave()" value="Save"> </form> <span id="resultId"></span> </fieldset> <script type="text/javascript" src="/js/ajaxfk.js"></script> <script type="text/javascript"> //检测名字是否已存在 function doCheck(){ //1.定义申请的url var url="http://localhost/doCheck"; //2.定义申请参数 var name=document.forms[0].name.value; var params=`name=${name}`; //3.发送ajax get申请 $$.doAjaxGet(url,params,(result)=>{ document.getElementById("resultId").innerHTML= `<font color=red>${result}</font>`; }); } //保留表单中名字的值 function doSave(){//debugger,log,排除法 //1.申请url const url="http://localhost/doSave"; //2.申请参数 let name=document.forms[0].name.value; let params=`name=${name}`; //3.发送ajax post申请 $$.doAjaxPost(url,params,(result)=>{ alert(result); }) } </script></body></html>ajax-05代码<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title></head><body> <h1>The Ajax 05 Page</h1> <fieldset> <legend>Ajax 表单申请</legend> <form> <input type="text" id="nameId" name="name" onblur="doCheck()"> <input type="button" onclick="doSave()" value="Save"> </form> <span id="resultId"></span> </fieldset> <script type="text/javascript" src="/js/ajaxfk02.js"></script> <script type="text/javascript"> //检测名字是否已存在 function doCheck(){ //1.定义申请的url var url="http://localhost/doCheck"; //2.定义申请参数 var name=document.forms[0].name.value; var params=`name=${name}`; //3.发送ajax get申请 $$.doAjaxGet(url,params,(result)=>{ document.getElementById("resultId").innerHTML= `<font color=red>${result}</font>`; }); } //保留表单中名字的值 function doSave(){//debugger,log,排除法 //1.申请url const url="http://localhost/doSave"; //2.申请参数 let name=document.forms[0].name.value; let params=`name=${name}`; //3.发送ajax post申请 $$.doAjaxPost(url,params,(result)=>{ alert(result); }) } </script></body></html>axios-ajax-01<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title></head><body><button onclick="doAjaxGet()">doAjaxGet</button><button onclick="doAjaxPost()">doAjaxPost</button><span id="result"></span><script src="https://unpkg.com/axios/dist/axios.min.js"></script><script type="text/javascript"> function doAjaxGet(){ axios.get('/jquery/doAjaxGet',{params:{msg:"hello axios"}}) .then( (r)=>{//服务响应状态为200时执行then函数内容 console.log(r.data); //document.getElementById("result").innerHTML=r.data; document.querySelector("#result").innerHTML=r.data; }) .catch((err)=>{//服务端响应状态非200时，执行catch函数。 console.log(err); }); } function doAjaxPost(){ axios.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded'; axios.post('/jquery/doAxiosPost',{"id":100,"title":"axios"}) .then( (r)=>{//服务响应状态为200时执行then函数内容 console.log(r.data); //document.getElementById("result").innerHTML=r.data; document.querySelector("#result").innerHTML=r.data; }) .catch((err)=>{//服务端响应状态非200时，执行catch函数。 console.log(err); }); }</script></body></html>jquery ajax 01<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title></head><body><h1>The Jquery ajax 01 Page</h1><fieldset> <legend>Jquery Ajax function </legend> <button onclick="doGet()">$.get(...)</button> <button onclick="doPost()">$.post(...)</button> <button onclick="doAjax()">$.ajax(...)</button> <button onclick="doLoad()">$(...).load(...)</button> <span id="resultId"></span></fieldset><script type="text/javascript" src="/js/jquery.min.js"></script><script type="text/javascript"> function doGet(){ //1.申请url var url="/jquery/doAjaxGet"; //2.申请参数 var params="msg=hello jquery ajax get method"; //3.发送异步申请 $.get(url,params,(result)=>{ $("#resultId").html(result); }) } function doPost(){ //1.申请url var url="/jquery/doAjaxPost"; //2.申请参数 var params="id=10&&title=AAA"; //3.发送异步申请 $.post(url,params,(result)=>{ $("#resultId").html(result); }) } function doAjax(){ //1.申请url var url="/jquery/doAjaxPost"; //2.申请参数 var params="id=10&&title=AAA"; //3.发送异步申请 $.ajax({ type:"POST",//能够省略，默认为get申请 url:url, data:params,//能够省略(无需向服务端传递参数) dataType:"text",//能够省略(由ajax函数外部基于返回值进行匹配解决) async:true,//能够省略，默认为true，示意异步 success:function(result){//解决服务端返回的失常信息 $("#resultId").html(result); }, error:function(xhr){//解决服务端返回的异样信息 console.log(xhr.statusText); $("#resultId").html(xhr.statusText); } }) } function doLoad(){ //1.申请url var url="/jquery/doAjaxGet"; //2.申请参数 var params="msg=hello jquery ajax get method"; //3.发送异步申请 //通过load函数向服务端发送异步申请，将服务端响应的后果异步更新到 //resultId对应的地位 $("#resultId").load(url,params); } //......</script></body></html>

关于springboot:第五天的代码

pojo层层层层层层层层层层层层层层层//@AllArgsConstructor //增加基于全副属性构建的构造函数//@NoArgsConstructor //增加无参构造函数@ToString@Getter@Setter//@Data //增加此注解会在Goods类中主动增加set,get,toString等办法public class Goods {//Goods.class private Long id;//id bigint primary key auto_increment private String name;//name varchar(100) not null private String remark;//remark text private Date createdTime;//createdTime datetime}//lombok底层基于字节码技术为类增加相干办法或属性dao层层层层层层层层层层层层层层@Mapperpublic interface GoodsDao {//这个接口在运行时零碎底层会产生其实现类,但没有源码(只有字节码). @Update("update tb_goods set name=#{name},remark=#{remark} where id=#{id} ") int updateGoods(Goods goods); @Insert("insert into tb_goods(name,remark,createdTime) values (#{name},#{remark},#{createdTime})") int insertGoods(Goods goods); @Select("select id,name,remark,createdTime from tb_goods where id=#{id}") Goods findById(Integer id); @Select("select id,name,remark,createdTime from tb_goods") List<Goods> findGoods(); @Delete("delete from tb_goods where id=#{id}") int deleteById(Integer id);}service 层层层层层层层层层层层层/** * 商品模块业务接口: * 负责: * 1)外围业务 * 2)拓展业务(记录日志,缓存,事务管制,权限管制,...) */public interface GoodsService { Goods findById(Integer id); int updateGoods(Goods goods); int saveGoods(Goods goods); /** * 查问所有商品信息 * @return */ List<Goods> findGoods(); int deleteById(Integer id);}service imp实现层实现层实现层实现层实现层@Slf4j@Servicepublic class GoodsServiceImpl implements GoodsService { @Autowired private GoodsDao goodsDao; //private static final Logger log=LoggerFactory.getLogger(GoodsServiceImpl.class); @Override public List<Goods> findGoods() { long t1=System.currentTimeMillis(); List<Goods> list=goodsDao.findGoods(); long t2=System.currentTimeMillis(); log.info("findGoods().time:{}",(t2-t1)); return list; } @Override public Goods findById(Integer id) { return goodsDao.findById(id); } @Override public int updateGoods(Goods goods) { // TODO Auto-generated method stub return goodsDao.updateGoods(goods); } @Override public int saveGoods(Goods goods) { // TODO Auto-generated method stub goods.setCreatedTime(new java.util.Date()); return goodsDao.insertGoods(goods); } @Override public int deleteById(Integer id) { try{Thread.sleep(5000);}catch(Exception e) {} return goodsDao.deleteById(id); }}Controller 层层层层层层层层层@Controller@RequestMapping("/goods/")public class GoodsController { @Autowired private GoodsService goodsService; @RequestMapping("doGoodsAddUI") public String doGoodsAddUI() { return "goods-add"; } @RequestMapping("doFindById/{id}") public String doFindById(@PathVariable Integer id,Model model) { Goods goods=goodsService.findById(id); model.addAttribute("goods",goods); return "goods-update";//此view由谁解析?ViewResolver(ThymeleafViewResolver) //这里的ThymeleafViewResolver做了什么? //1)在viewname的根底上增加前缀和后缀(/templates/pages/goods-update.html),并找到对应的view(真正的页面对象) //2)将model中的数据取出,而后填充到view上(/templates/pages/goods-update.html) //3)将view交给DispatcherServlet } @RequestMapping("doUpdateGoods") public String doUpdateGoods(Goods goods) { goodsService.updateGoods(goods); return "redirect:/goods/doGoodsUI"; } @RequestMapping("doSaveGoods") public String doSaveGoods(Goods goods) { goodsService.saveGoods(goods); return "redirect:/goods/doGoodsUI"; } @RequestMapping("doDeleteById/{id}") public String doDeleteById(@PathVariable Integer id) { goodsService.deleteById(id); return "redirect:/goods/doGoodsUI"; } @RequestMapping("doGoodsUI") public String doFindGoods(Model model)throws Exception { //Thread.sleep(7000); List<Goods> list=goodsService.findGoods(); model.addAttribute("list", list); return "goods"; }}goods 层层层层层层<!DOCTYPE html><html xmlns:th="http://www.thymeleaf.org"><head><meta charset="UTF-8"><title>Insert title here</title></head><body> <h1>The Goods Page</h1> <a th:href="@{/goods/doGoodsAddUI}">增加商品</a> <table> <thead> <tr> <th>id</th> <th>name</th> <th>remark</th> <th>createdTime</th> <th colspan="2">operation</th> </tr> </thead> <tbody> <tr th:each="g:${list}"> <td th:text="${g.id}">1</td> <td th:text="${g.name}">AAA</td> <td th:text="${g.remark}">AAAAA</td> <td th:text="${#dates.format(g.createdTime,'yyyy/MM/dd HH:mm')}">2020/09/01</td> <td><a th:href="@{/goods/doDeleteById/{id}(id=${g.id})}">delete</a></td> <td><a th:href="@{/goods/doFindById/{id}(id=${g.id})}">update</a></td> </tr> </tbody> </table></body></html>goods-add 增加代码<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title><style type="text/css"> ul li {list-style-type: none}</style></head><body> <h1>The Goods Add Page</h1> <form th:action="@{/goods/doSaveGoods}" method="post"> <ul> <li>name: <li><input type="text" name="name"> <li>remark: <li><textarea cols="30" rows="5" name="remark"></textarea> <li><input type="submit" value="Save Goods"> </ul> </form></body></html>goods-update 批改代码<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title><style type="text/css"> ul li {list-style-type: none}</style></head><body> <h1>The Goods Update Page</h1> <form th:action="@{/goods/doUpdateGoods}" method="post"> <input type="hidden" name="id" th:value="${goods.id}"> <ul> <li>name: <li><input type="text" name="name" th:value="${goods.name}"> <li>remark: <li><textarea cols="30" rows="5" name="remark" th:text="${goods.remark}"></textarea> <li><input type="submit" value="Update Goods"> </ul> </form></body></html>配置文件...# serverserver.port=80server.servlet.context-path=/spring.main.banner-mode=console# spring datasourcespring.datasource.url=jdbc:mysql:///dbgoods?serverTimezone=GMT%2B8&characterEncoding=utf8spring.datasource.username=rootspring.datasource.password=root#spring mybatismybatis.mapper-locations=classpath:/mapper/*/*.xml#spring thymeleafspring.thymeleaf.cache=falsespring.thymeleaf.prefix=classpath:/templates/pages/spring.thymeleaf.suffix=.html#spring actuatormanagement.endpoints.web.exposure.include=*#Spring loglogging.level.com.cy=debug

关于springboot:第四天代码

pojo层层层层层层层层层层层层层层层package com.cy.pj.goods.pojo;import java.util.Date;public class Goods { private Long id;//id bigint primary key auto_increment private String name;//name varchar(100) not null private String remark;//remark text private Date createdTime;//createdTime datetime public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getRemark() { return remark; } public void setRemark(String remark) { this.remark = remark; } public Date getCreatedTime() { return createdTime; } public void setCreatedTime(Date createdTime) { this.createdTime = createdTime; } @Override public String toString() { return "Goods [id=" + id + ", name=" + name + ", remark=" + remark + ", createdTime=" + createdTime + "]"; }}dao层层层层层层层层层层层层层层/** @Mapper 用于形容(做标记)数据层拜访接口,用于通知mybatis框架, 应用此注解形容的接口要由底层为创立实现类.在实现类中基于mybatis API实现与数据库的交互.这个类的对象最初会交给spring治理. FAQ 咱们增加了MyBatis-Spring-Boot-Starter这个依赖当前,此依赖外部做了什么? /@Mapperpublic interface GoodsDao {//还有一些企业这个GoodsDao的名字会定义为GoodsMapper @Insert("insert into tbgoods(name,remark,createdTime) values (#{name},#{remark},#{createdTime})") int insertGoods(Goods goods); @Update("update tbgoods set name=#{name},remark=#{remark} where id=#{id}") int updateGoods(Goods goods); /**基于商品id查问商品信息/ @Select("select from tbgoods where id={id}") Goods findById(Integer id); @Select("select from tb_goods") List<Goods> findGoods(); /** 基于id执行商品信息的删除,在mybatis中如果SQL映射语句比较简单能够间接在dao办法上以注解形式进行定义. @param id 商品id @return 删除的行数/ @Delete("delete from tbgoods where id=#{id}") int deleteById(Integer id); /** 基于多个id执行商品删除业务 @param ids 可变参数,用于接管传入的商品id值 @return 删除行数 /int deleteObjects(@Param("ids")Integer...ids);}service层层层/** 商品模块的业务层接口，负责具体业务规范的定义 @author pc */public interface GoodsService { Goods findById(Integer id); int saveGoods(Goods goods); int updateGoods(Goods goods); int deleteById(Integer id); List<Goods> findGoods();}service层 imp实现层 imp实现层 imp实现层 imp实现层/*** 业务层对象，后续会在此对象中执行： 1)外围业务(例如，点击购买商品信息，要生成点单项信息，扣减库存，....) 2)扩大业务(例如，事务管制，权限管制，日志记录，。。。。) /@Service //是一个非凡的@Componentpublic class GoodsServiceImpl implements GoodsService { private static final Logger log= LoggerFactory.getLogger(GoodsServiceImpl.class); @Autowired private GoodsDao goodsDao; @Override public Goods findById(Integer id) { return goodsDao.findById(id); } @Override public int saveGoods(Goods goods) { goods.setCreatedTime(new java.util.Date()); return goodsDao.insertGoods(goods); } @Override public int updateGoods(Goods goods) { return goodsDao.updateGoods(goods); } @Override public List<Goods> findGoods() { return goodsDao.findGoods(); } @Override public int deleteById(Integer id) { long t1=System.currentTimeMillis(); int rows=goodsDao.deleteById(id); long t2=System.currentTimeMillis();//System.out.println(log.getClass().getName()); log.info("deleteById execute time : {}",(t2-t1)); return rows; }}Controller 层层层层层层层层层层层@Controller //@Service,@Component@RequestMapping("/goods/")public class GoodsController { //has a+DI @Autowired private GoodsService goodsService; @RequestMapping("doFindById/{id}") public String doFindById(@PathVariable Integer id,Model model) { Goods goods=goodsService.findById(id); model.addAttribute("goods",goods); return "goods-update"; } @RequestMapping("doGoodsAddUI") public String doGoodsAddUI() { return "goods-add" } @RequestMapping("doSaveGoods") public String doSaveGoods(Goods goods) {//"name=aaa&&remark=aaaaaaaaa" goodsService.saveGoods(goods); return "redirect:/goods/doGoodsUI"; } @RequestMapping("doUpdateGoods") public String doUpdateGoods(Goods goods) { goodsService.updateGoods(goods); return "redirect:/goods/doGoodsUI"; } /** 基于商品id执行商品删除操作 @param id 商品id,肯定要与客户端传过来的参数id名雷同. @return 重定向到doGoodsUI rest格调:一种软件架构编码格调,其设计的目标次要是在异构零碎之间实现兼容(跨平台) rest格调的url的定义:{a}/{b}/{c},这里的a,b,c别离为变量如果心愿办法参数的值来自rest格调的url, 能够应用@PathVariable注解对办法参数进行形容(办法参数名须要和url中{}外部变量名雷同)/ @RequestMapping("doDeleteById/{id}") public String doDeleteById(@PathVariable Integer id) { goodsService.deleteById(id); return "redirect:/goods/doGoodsUI"; }//这里redirect示意重定向,前面的第一个"/"默认地位为localhost:port/context-path/ @RequestMapping("doGoodsUI") public String doGoodsUI(Model model) {//ModelAndView中的model对象 //调用业务层办法获取商品信息 List<Goods> list= goodsService.findGoods(); //将数据存储到申请作用域 model.addAttribute("goods", list); return "goods";//viewname //FAQ: //1)返回的viewname会给谁?谁调用doGoodsUI办法就给谁(DispatcherServlet). //2)谁负责解析viewname?ViewResolver(ThymleafViewResolver) //3)viewname解析的后果会响应到哪里?(prefix+viewname+suffix会响应到客户端) }}sql语句......<mapper namespace="com.cy.pj.goods.dao.GoodsDao"> <delete id="deleteObjects"> delete from tb_goods where id in  <foreach collection="array" open="(" close=")" separator="," item="id"> #{id} </foreach> </delete> </mapper>html页面页面页面页面页面<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title></head><body> <h1>The Goods Page</h1><a th:href="@{/goods/doGoodsAddUI}">增加商品</a><table> <thead> <tr> <th>id</th> <th>name</th> <th>remark</th> <th>createdTime</th> <th colspan="2">operation</th> </tr> </thead> <tbody> <tr th:each="g:${goods}"> <td th:text="${g.id}">1</td> <td th:text="${g.name}">AAAAAAA</td> <td th:text="${g.remark}">AA....</td> <td th:text="${#dates.format(g.createdTime, 'yyyy/MM/dd HH:mm')}">2020/08/31</td> <td><a href="#" th:href="@{/goods/doDeleteById/{id}(id=${g.id})}">delete</a></td> <td><a href="#" th:href="@{/goods/doFindById/{id}(id=${g.id})}">update</a></td> </tr> </tbody></table></body></html>sql 增加语句<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title><style type="text/css"> ul li {list-style-type: none}</style></head><body> <h1>The Goods Add Page</h1> <form th:action="@{/goods/doSaveGoods}" method="post"> <ul> <li>name: <li><input type="text" name="name"> <li>remark: <li><textarea rows="3" cols="30" name="remark"></textarea> <li><input type="submit" value="Save Goods"> </ul> </form></body></html>批改sql语句:<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title><style type="text/css"> ul li {list-style-type: none}</style></head><body> <h1>The Goods Update Page</h1> <form th:action="@{/goods/doUpdateGoods}" method="post"> <input type="hidden" name="id" th:value="${goods.id}"> <ul> <li>name: <li><input type="text" name="name" th:value="${goods.name}"> <li>remark: <li><textarea rows="3" cols="30" name="remark" th:text="${goods.remark}"></textarea> <li><input type="submit" value="Update Goods"> </ul> </form></body></html>配置文件 # serverserver.port=80#server.servlet.context-path=/# close bannerspring.main.banner-mode=off# Spring DataSourcespring.datasource.url=jdbc:mysql:///dbgoods?serverTimezone=GMT%2B8&characterEncoding=utf8spring.datasource.username=rootspring.datasource.password=root# spring mybatismybatis.mapper-locations=classpath:/mapper/*/*.xml# spring thymleafspring.thymeleaf.cache=falsespring.thymeleaf.prefix=classpath:/templates/pages/spring.thymeleaf.suffix=.html# spring loglogging.level.com.cy=debug

关于springboot:第三天代码

* 1)如果将此类交给spring治理，请问默认spring何时创立此对象？你怎么晓得的？ * 2)如果一个对象创立当前，存储到内存，长时间不必会有什么影响？ * 3)你晓得Spring中，Bean对象的提早加载个性吗？(理解) * 4)你晓得什么场景下这个对象适宜提早加载吗？大对象，稀少用。 * 5)对象创立当前，利用完结要销毁对象吗？ * 6)程序中的每个对象都有生命周期(正确)，不见得每个对象都有生命周期办法。 */@Scope("prototype") //每次从spring容器获取对象都会创立一个新的实例//@Scope("singleton")//默认就是单例作用域(这个类的实例在一个spring容器中默认只有一份)//@Lazy(false)//默认为true//@Lazy(true)//此注解用于通知spring框架，它形容的类的实例，如果临时用不到，就不要先创立。//@Lazy(value=true)@Componentpublic class ObjectPool { /**构建对象时会执行对象的构造函数*/ public ObjectPool() { System.out.println("ObjectPool()"); } /**@PostConstruct 注解形容的办法会在对象构建当前执行，用于执行一些初始化操作*/ @PostConstruct public void init() { System.out.println("init()"); } /**@PreDestroy 注解形容的办法会在单例对象销毁之前执行，spring容器在销毁之前 * 会先将容器(Bean池)中的对象进行移除，在移除对象时，如果对象中定义了生命周期销 * 毁办法，此时还会调用对象的生命周期销毁办法(在这样的办法中能够做一些资源开释操 * 作)。 * */ @PreDestroy public void close() { System.out.println("close()"); }}接口dao层级package com.cy.pj.common.cache;public interface Cache {}service实现层package com.cy.pj.common.cache;import org.springframework.stereotype.Component;@Component //如果省略名字，则bean的名字默认为类名，而后首字母小写。//@Component("softCache")//@Component 注解形容bean时给bean起名字为softCachepublic class SoftCache implements Cache {//map.put("softCache",object instance)}service实现层package com.cy.pj.common.cache;import org.springframework.stereotype.Component;@Componentpublic class WeakCache implements Cache{}

关于springboot:第二天代码

第二天代码:/** * FAQ? * 1)如果将此类交给spring治理，请问默认spring何时创立此对象？你怎么晓得的？ * 2)如果一个对象创立当前，存储到内存，长时间不必会有什么影响？ * 3)你晓得Spring中，Bean对象的提早加载个性吗？(理解) * 4)你晓得什么场景下这个对象适宜提早加载吗？大对象，稀少用。 * 5)对象创立当前，利用完结要销毁对象吗？ * 6)程序中的每个对象都有生命周期(正确)，不见得每个对象都有生命周期办法。*/@Scope("prototype") //每次从spring容器获取对象都会创立一个新的实例//@Scope("singleton")//默认就是单例作用域(这个类的实例在一个spring容器中默认只有一份)//@Lazy(false)//默认为true//@Lazy(true)//此注解用于通知spring框架，它形容的类的实例，如果临时用不到，就不要先创立。//@Lazy(value=true)@Componentpublic class ObjectPool { /**构建对象时会执行对象的构造函数*/ public ObjectPool() { System.out.println("ObjectPool()"); } /**@PostConstruct 注解形容的办法会在对象构建当前执行，用于执行一些初始化操作*/ @PostConstruct public void init() { System.out.println("init()"); } /**@PreDestroy 注解形容的办法会在单例对象销毁之前执行，spring容器在销毁之前 * 会先将容器(Bean池)中的对象进行移除，在移除对象时，如果对象中定义了生命周期销 * 毁办法，此时还会调用对象的生命周期销毁办法(在这样的办法中能够做一些资源开释操 * 作)。 * */ @PreDestroy public void close() { System.out.println("close()"); }}

关于springboot:第一天代码

第一天package com.cy.pj.common.cache;import org.springframework.stereotype.Component;/**FAQ?在SpringBoot工程中如何将一个类的实例交给spring创立和治理。 1)将类放在启动类所在包或子包中 2)将类应用spring框架中指定注解进行形容，@Component@Component("defaultCache") //注解起的作用就是做标记public class DefaultCache {}第一天罕用注解简绍:/** 任何一个我的项目都有一个启动入口,在springboot中的启动类须要有 @SpringBootApplication 注解进行形容,并且在类中会定义一个main 办法,main办法在运行时会读取配置文件,并加载指定资源,而后进行初始化操作. FAQ? 1)SpringBoot我的项目中配置文件起源? a)SpringBoot官网定义(个别为一些根底配置),例如spring.factories(在springboot主动配置依赖中) b)第三方定义(例如日志零碎-log4j.xml,.....) c)咱们本人定义(application.properties,.....) 2)SpringBoot我的项目中的资源加载?(资源能够了解为咱们的class文件) a)JDK类文件(Object,....) b)Spring类文件,第三办法类文件,... c)本人定义的类文件 3)Spring中的我的项目资源初始化? a)构建实例对象 b)基于对象存储数据(例如配置信息,默认值)///JVM参数(理解): //跟踪类加载:-XX:+TraceClassLoading//CommandLineRunner 此接口定义了一种标准，能够在spring框架初始化当前执行一些逻辑。@SpringBootApplicationpublic class CgbSpringboot01Application implements CommandLineRunner {/** main办法由jvm调用 @param args JVM运行时给main办法传入值 */ public static void main(String[] args) {System.out.println("mains.args="+Arrays.toString(args));SpringApplication.run(CgbSpringboot01Application.class, args); } //@Autowired 用于通知spring框架，为这个属性注入一个值。 @Autowired private BeanFactory beanFactory; /**在此办法能够获取spring容器中的一些初始化资源 @param args 与main办法中的参数是一样的 */ @Override public void run(String... args) throws Exception { System.out.println("run.args="+Arrays.toString(args)); System.out.println("beanFactory="+beanFactory);//DefaultListableBeanFactory }}

关于springboot:springbootroute六整合JApiDocs生成接口文档

上一篇文章中介绍了应用Swagger生成接口文档，十分不便，性能也非常弱小。如果非要说Swaager有什么毛病，想必就是注解写起来比拟麻烦。如果我说有一款不必写注解，就能够生成文档的工具，你心动了吗？他就是咱们明天的配角——JApiDocs。上面咱们一起来看看如何应用！一、增加依赖<dependency> <groupId>io.github.yedaxia</groupId> <artifactId>japidocs</artifactId> <version>1.3</version></dependency>二、配置生成参数咱们新建一个我的项目，而后轻易写一个main办法，减少生成文档的配置，而后运行main办法。 DocsConfig config = new DocsConfig();config.setProjectPath("F:\\Java旅途\\japi-docs"); // 我的项目根目录config.setProjectName("japi-docs"); // 项目名称config.setApiVersion("V1.0"); // 申明该API的版本config.setDocsPath("F:\\test"); // 生成API 文档所在目录config.setAutoGenerate(Boolean.TRUE); // 配置主动生成Docs.buildHtmlDocs(config); // 执行生成文档三、编码标准因为JApiDocs是通过解析Java源码来实现的，因而如果要想实现想要的文档，还是须要遵循肯定的标准。 3.1 类正文、办法正文和属性正文如果咱们想生成类的正文，咱们能够间接在类上加正文，也能够通过加@description来生成。 /** * 用户接口类 */@RequestMapping("/api/user")@RestControllerpublic class UserController {}/** * @author Java旅途 * @Description 用户接口类 * @Date 2020-06-15 21:46 */@RequestMapping("/api/user")@RestControllerpublic class UserController {}如果咱们想生成办法的正文，只能间接加正文，不能通过加@description来生成。 /** * 查问用户 * @param age 年龄 * @return R<User>*/@GetMapping("/list")public R<User> list(@RequestParam int age){ User user = new User("Java旅途", 18); return R.ok(user);}JApiDocs能够主动生成实体类，对于实体类属性的正文有三种形式，生成的成果都是一样的，如下： ...

关于springboot:第四阶段-day-927-Spring-Boot

1 商品后盾治理1.1 动静实现商品分类展示1.1.1 异步树加载控件阐明1).树形控件树形 `每个节点都具备以下属性：id：节点ID，对加载近程数据很重要。text：显示节点文本。state：节点状态，'open' 或 'closed'，默认：'open'。如果为'closed'的时候，将不主动开展该节点。checked：示意该节点是否被选中。attributes: 被增加到节点的自定义属性。children: 一个节点数组申明了若干节点。` 2).异步树阐明树控件读取URL。子节点的加载依赖于父节点的状态。当开展一个关闭的节点，如果节点没有加载子节点，它将会把节点id的值作为http申请参数并命名为’id’，通过URL发送到服务器下面检索子节点。如果用户点击父节点须要开展子节点时,会将父节点的id的值当做参数传递. 1.1.2 编辑ItemCatController(形式一) `/** * 业务需要: 用户通过ajax申请,动静获取树形构造的数据. * url: http://localhost:8091/item/cat/list * 参数: 只查问一级商品分类信息 parentId = 0 * 返回值后果: List<EasyUITree> * * 注意事项: * 1.树形构造初始化时不会传递任何信息.只有开展子节点时传递Id * 2.页面传递什么样的数据,后端必须接管什么样的数据 * * id: 296 */ @RequestMapping("/list") public List<EasyUITree> findItemCatList(Long id){ Long parentId = (id==null?0L:id); return itemCatService.findItemCatList(parentId); }` 1.1.3 编辑ItemCatController(形式二)能够利用注解动静获取参数,并且实现转化. `//2.个别写业务须要见名知意 @RequestMapping("/list") public List<EasyUITree> findItemCatList( @RequestParam(value = "id",defaultValue = "0") Long parentId){ //形式1 //Long parentId = (id==null?0L:id); return itemCatService.findItemCatList(parentId); }` ...

关于springboot:springbootroute五整合swagger生成接口文档

目前，大多数公司都采纳了前后端拆散的开发模式，为了解决前后端人员的沟通问题，后端人员在开发接口的时候会抉择应用swagger2来生成对应的接口文档，swagger2提供了弱小的页面调试性能，这样能够无效解决前后端人员沟通难的问题。上面咱们应用SpringBoot联合swagger2生成Restful API文档。一搭建我的项目，引入依赖新建一个spring-boot-swaager的我的项目，引入swaager2的依赖，因为swagger2的ui不是很好看，这里将应用开源的swagger-bootstrap-ui做为ui。引入依赖  <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.9.2</version></dependency><dependency> <groupId>com.github.xiaoymin</groupId> <artifactId>swagger-bootstrap-ui</artifactId> <version>1.9.6</version></dependency>我的项目中配置swagger相干信息 @Configuration@EnableSwagger2public class configuration { @Bean public Docket createRestApi(){ return new Docket(DocumentationType.SWAGGER_2) .apiInfo(apiInfo()) .select() .apis(RequestHandlerSelectors.basePackage("com.javatrip.swagger.controller")) .paths(PathSelectors.any()) .build(); } private ApiInfo apiInfo(){ return new ApiInfoBuilder() // 题目 .title("某某我的项目接口文档") // 形容 .description("swagger2接口文档应用演示") // 版本 .version("1.0") // 许可证 .license("MIT") // 许可证地址 .licenseUrl("www.xx.com") // 服务端地址 .termsOfServiceUrl("https://www.cnblogs.com/zhixie/") // 分割信息 .contact(new Contact("java旅途","https://www.cnblogs.com/zhixie/","binzh303@163.com")) .build(); }}拜访门路，查看生成成果文章中应用的这个ui，接口文档地址为ip:port/doc.html，生成的文档信息如下： ...

关于springboot:动吧所有内容总结

搜寻框含糊搜寻数据并判断如果是空则不执行 where外面的内容<mapper namespace="com.cy.pj.sys.dao.SysLogDao">指定数据为dao层  <select id="getRowCount" resultType="int"> select count(*) from sys_logs <where> <if test="username!=null and username!=''"> username like concat("%",#{username},"%") </if> </where> </select></mapper>这是一种逻辑思维当前业务就要这样去写的//基于条件查问用户行为日志记录总数 //@param username 查问条件()用户名-基于此用户名进行含糊查问） //@return 查问到的记录总数 int getRowCont(String username);//这是一个搜寻框，依据用户名查问的总记录数 List<SysLog> findPageObjects(String username,查问条件 Integer startIndex, 起始地位 Integer pageSize);这个是分页面的大小每页最多显示多少条数据 <sql id="abcd">应用sql封装总数据提取共性 from sys_logs <where> <if test="username!=null and username!=''"> username like concat("%",#{username},"%") </if> </where> </sql>  <select id="findPageObjects" resultType="com.cy.pj.sys.pojo.SysLog"> 分页查问 select * <include refid="abcd"/>调用sql里的共性数据 order by createdTime desc limit #{startIndex},#{pageSize} </select> 总记录数据 <select id="getRowCount" resultType="int"> select count(*) <include refid="abcd"/>调用sql里的共性数据sql自定义的id值 </select>//service 层分页业务；public interface SysLogService { //用户名 //分页查问 //返回值封装了查问和计算结果的一个分页对象 pageObject<SysLog> findPageObjects(String username,Integer pageCurrent);} 02这个是定义的一个类 pojo层的类和上面对应 public class pageObject<T> implements Serializable{ private static final long serialVersionUID = 7372326137711610989L;//实现序列化接口 //总数数 private Integer rowCount;//池化思维 //当前页记录 private List<T> records;//加《T》是为了其余模块当前应用分页分享共性 //总页数 private Integer pageCount; //页面大小（每页最多显示多少条记录） private Integer pageSize; //以后页码值 private Integer pageCurrent; public pageObject(Integer rowCount, List<T> records, Integer pageSize, Integer pageCurrent) { super(); //依据业务需要近进行判断所须要的数据； this.rowCount = rowCount;//总数数 this.records = records;//当前页记录 this.pageCount = pageCount;//总页数 this.pageSize = pageSize;//页面大小（每页最多显示多少条记录） this.pageCurrent = pageCurrent;//以后页码值 //计算pageCount的值,办法2 this.pageCount=(this.rowCount-1)/pageSize+1; }}Serviceimpl层业务业务层业务层@Servicepublic class SysLogServiceImpl implements SysLogService { @Autowired private SysLogDao sysLogDao; @Override public pageObject<SysLog> findPageObjects(String username, Integer pageCurrent) { // TODO Auto-generated method stub if(pageCurrent==null||pageCurrent<1) throw new IllegalArgumentException("以后页码值有效"); //判断值 int rowCount=sysLogDao.getRowCont(username); if(rowCount==0) throw new ServiceException("没有找到对应后果");本人定义的异样应用这个异样要类继承 RuntimeException这个类是运行异样 //查问当前页数据 int pageSize=5;//这个值也能够从页面传递到服务器显示数据 int startIndex=(pageCurrent-1)*pageSize; List<SysLog> records=sysLogDao.findPageObjects(username, startIndex, pageSize); return new pageObject<SysLog>(rowCount, records, pageSize, pageCurrent); }}Controller层解决异样，解决异样语句 @Controller@RequestMapping("/log/")//这个当前如果用户传个——1则会报500这个谬误所以最好还是增加一个状态 public class SysLogController { @Autowired private SysLogService sysLogService; @RequestMapping("doFindPageObjects") @ResponseBody//以json字符串返回数据 public JsonResult doFindPageObjects(String username,Integer pageCurrent){// try { pageObject<SysLog> pageObject=sysLogService.findPageObjects(username, pageCurrent); return new JsonResult(pageObject);//没有谬误就返回正确的值// } catch (Exception e) {//能够不必这个认为这个当前如果还有异样怎么办哪？ //所以须要一个全局的解决异样;// return new JsonResult(e);//如果有谬误就返回状态就返回0 // TODO: handle exception } }这个就写js函数吧当前在欠缺吧！<script type="text/javascript"> //这个是管制分页总分页反正都有用 function doSetPagination(page) { //1.始化数据 $(".rowCount").html("总记录数(" + page.rowCount + ")"); $(".pageCount").html("总页数(" + page.pageCount + ")"); $(".pageCurrent").html("当前页(" + page.pageCurrent + ")"); //存储以后页码值 data函数用于在指定dom对象上存储数据去数据其根本语法为data(key,[value]); $("#pageId").data("pageCurrent", page.pageCurrent);//如果只有k则示意取值 data 属性必须有值能力用data $("#pageId").data("pageCount", page.pageCount); } //事件注册 //在pageId对应的对象上技能型click事件注册点击妻子元素first....等等执行doJUmpToPage $(function() {//on应用中央动静按键 $("#pageId").on("click", ".first,.pre,.next,.last", doJumpToPage); });//on语法 click //定义doJumpToPage办法通过此办法实现以后数据查问 function doJumpToPage() { //1.获取点击对象的class值 //prop是jquery中的一个操作属性的函数即泵语法prop（属性名【属性值】） var cls = $(this).prop("class");//prop用于获取dom对象属性值或赋值prop只取规范属性如class，id 或者 java有的语言值 //2.基于点击的对象执行pageCurrent值的批改 //2.1获取pageCurrent,pageCount的以后值这个值最好还是不要用全局变量 var pageCurrent = $("#pageId").data("pageCurrent"); //当前页 var pageCount = $("#pageId").data("pageCount");//总页数 //2.2批改pageCurrent的值 if (cls == "first") {//首页 pageCurrent = 1; } else if (cls == "pre" && pageCurrent > 1) {//上一页 pageCurrent--; } else if (cls == "next" && pageCurrent < pageCount) {//下一页 pageCurrent++; } else if (cls == "last") {//最初一页 pageCurrent = pageCount; } else { return;//其余状况什么也不做 } //3.对pageCurrent值进行从新绑定 $("#pageId").data("pageCurrent", pageCurrent);//重洗刷新页面 doGetObjects();//此函数定义在了类标页面 }分页加查问语句。。。<script type="text/javascript"> //第一步分页页面加载实现向服务端发动异步申请 $(function() {//此函数所有货色加载完最初执行;如果把js函数写在最上面也能够不写这个函数 $("#pageId").load("doPageUI")//把doPageUI加载到pageId doGetObjects();//刷新这个办法 //查询方法查询方法查询方法 $(".input-group-btn").on("click",".btn-search",doQueryObjects);//查问日志按钮进行注册 }) //查询方法 function doQueryObjects(){ //如果这里不初始化为1如果在某个页面就会搜寻不进去后果忘了能够删除试试 //以后页码初始化 $("#pageId").data("pageCurrent",1); //为什么要调用doGetObjects函数？ //重用js代码，简化jS代码编写。 doGetObjects(); } //第二步定义异步申请处理函数 function doGetObjects() { //定义url和参数 var url = "log/doFindPageObjects" var pageCurrent=$("#pageId").data("pageCurrent"); if(!pageCurrent) pageCurrent=1;//默认值 var params = {"pageCurrent" :pageCurrent};//默认页码值是第一页 //基于用户名查问试获取用户名这个参数值 var username=$("#searchNameId").val(); //这个值肯定和数据库里的值一样不能乱写 if(username) params.username=username;//查问时须要 //2.发动异步申请 //ajax申请的回调函数参数名能够是任意吗？能够必须合乎示意符的标准 $.getJSON(url, params, function(result) { //请问result是一个字符串还是json格局的js对象？对象 doHandleQueryResponseResult(result); });//非凡的ajax函数 } //第三步定义回调函数解决服务端的响应后果 function doHandleQueryResponseResult(result) {//JsonResult if (result.state == 1) {//定义状态信息 //更新table中tbody外部的数据 // records当前页记录 //这个其实也相当于调用办法 doSetTableBodyRows(result.data.records);//将数据出现在页面上这个也算刷新数据了 //更新页面page.html分页数据 doSetPagination(result.data); //将这个函数读取到page.html中 }else{ alert(result.message); } } function doSetTableBodyRows(records){ //1.获取tbody对象 ,并清空原有内容 var tBody=$("#tbodyId"); tBody.empty();//清空原有的内容 //2迭代 result，将流动信息追加到tbody中 records.forEach((item)=>{//代表数组的某个元素 //将原有的数据替换掉更新新的数据 //应用了模板字符拼接办法 tBody.append( `<tr> <td><input type='checkbox'value=${item.id}></td>/*模板字符拼接 */ <td>${item.username}</td> <td>${item.operation}</td> <td>${item.method}</td> <td>${item.params}</td> <td>${item.time}</td> <td>${item.ip}</td> </tr>` ); }); }删除操作单删除今天在改.on("click",".btn-delete",doDeleteObjects);//这个函数还能够这样写 }) //input-group-btn查问事件 //btn-delete 删除事件 //btn-search 这个是分页事件 //删除操作事件处理 function doDeleteObjects(){ //1.获取选中的id值 var ids=doGetCheckedIds(); if(ids.length==0){ alert("至多抉择一个");//弹出一个框 return; } var url="log/doDeleteObjects"; var params={"ids":ids.toString()}; $.post(url,params,function(result){//post提交形式 if(result.state==1){ alert(result.message);//弹框 doGetObjects(); }else{ alert(result.message);//弹框 } }); } function doGetCheckedIds(){ //定义一个数组，用于存储选中的checkbox的id值 var array=[]; //获取tbody中所有类型为checkbox的input元素 $("#tbodyId input[type=checkbox]"). each(function(){ //假如此元素的checked属性的值为true if($(this).prop("checked")){ //调用数组对象的push办法将选中的值存储到数组中 array.push($(this).val()); } }); return array;//返回

关于springboot:springbootroute一Controller接收参数的几种方式

Controller接管参数的罕用形式总体能够分为三类。第一类是Get申请通过拼接url进行传递，第二类是Post申请通过申请体进行传递，第三类是通过申请头部进行参数传递。 1 @PathVariable接管参数申请形式：localhost:7001/param/123 申请示例：代码示例： @GetMapping("{id}")public String getPathVariable(@PathVariable String id){ return "id="+id;}2 @RequestParam接管参数应用这个注解须要留神两个点，一是加了这个参数后则申请中必须传递这个参数，二是@RequestParam这个注解能够指定名字，申请参数必须和指定的这个名字雷同，如果不指定，则默认为具体参数名。申请形式：localhost:7001/param/getParam?myId=18 申请示例：代码示例： @GetMapping("getParam")public String getRequestParam(@RequestParam("myId") String id){ return "id="+id;}3 无注解传参这种形式和2比照，最大的区别就是这个参数不是必传的，申请门路上能够不传递。申请形式：localhost:7001/param/getString?id=18 申请示例：代码示例： @GetMapping("getString")public String getString(String id){ return "id="+id;}4 HttpServletRequest接管参数申请形式：localhost:7001/param/getRequest?id=18 申请示例：代码示例： @GetMapping("getRequest")public String getRequest(HttpServletRequest request){ String id = request.getParameter("id"); return "id="+id;}5 @RequestBody接管申请体参数这种形式个别用来传递实体对象，加了这个注解后，参数也是必传的。申请形式：{"id":18} 申请示例：代码示例： @PostMapping("getBody")public String getBody(@RequestBody String id){ return "id="+id;}6 @RequestHeader接管申请头参数申请示例：代码示例： @PostMapping("getHeader")public String getHeader(@RequestHeader String id){ return "id="+id;}此是spring-boot-route系列的第一篇文章，这个系列的文章都比较简单，次要目标就是为了帮忙首次接触Spring Boot 的同学有一个零碎的意识。本文已收录至我的github，欢送各位小伙伴star！ ...

关于springboot:最简单的微服务部署测试实践

微服务特地适宜业务简单，开发队伍宏大的我的项目。微服务能够达到化整为零，简化单个服务，升高沟通老本的成果。但微服务在性能上比单体服务低，也会有数据冗余的问题，要联合本身状况，不要盲目崇拜。本文介绍一种简略的微服务技术架构。帮忙大家对微服务如何部署，如何开发有个初步的意识。一个简略的微服务架构部署图如下 nginx：对外对立入口，依据url将申请散发到不同微服务，用ip:port辨别不同的微服务。也会间接解决一些动态资源的拜访，自身就是web服务器。 springboot+dubbo：spring boot是目前最风行的开发web服务的框架（jsp，ejb，ssh这些框架过于老旧），它和微服务没有必然联系，但它联合dubbo能够开发微服务，要求就是spring boot工程要import dubbo.jar或者应用maven引入dubbo。配置dubbo-application.xml，外面写好zookeeper服务地址端口以及提供者和消费者要注册的接口办法。一个微服务要调用另一个微服务的办法，只须要@Autowired注册接口类的对象，用对象调用办法即可。麻烦点的是各个微服务对同一个接口办法要有统一的接口形容java文件，应用maven治理形容接口的jar包能够无效解决接口统一的问题。最初打jar包，java -jar ***.jar一个微服务就启动了。 zookeeper：springboot须要dubbo，而dubbo最举荐的服务注册核心是zookeeper，相当于一个布告板，各个微服务都能够看到下面注册的提供者和消费者的接口办法 DB：MySQL Oracle等 redis：缓存session数据，和其它有必要缓存的业务数据 tomcat+dubbo-admin：dubbo管理系统，用于监控和排查故障，部署在tomcat下，能够在浏览器上查看各个微服务的运行状况，查看某个办法是否能够被失常调用。积分查问业务场景，帮忙了解微服务。B服务提供查看登陆状态性能。A服务提供查问账号积分性能。当用户在app点击查问积分时，nginx看见url里有查问积分关键字，会依据nginx.conf的配置将申请发送到A服务，app会有个sessionid发送给A服务，A服务近程调用B服务的查看登陆状态的接口，将sessionid传给接口，B服务接口被调用，应用sessionid到redis查用户信息，如果查问到redis有对应的用户信息，将用户信息返回，A服务接管到近程调用接口返回的用户信息userid，接下来依据用户信息到数据库DB查问积分状况。这就是两个微服务配合实现一个业务的例子，用到了架构图中的全副单元。查问登陆状态的要求在各个业务都存在，所以会有很多微服务须要近程调用B服务的接口。同时每个微服务能够即是提供者，又是消费者。在windows下配置一套残缺的微服务开发环境。nginxD:\Program Files\nginx-1.8.1>start nginx.exe 胜利后浏览器如下 MySQLD:\Program Files\mysql-8.0.12-winx64\bin>mysqld --console redisD:\Program Files\Redis-x64-3.0.504>redis-server.exe redis.windows.conf 图我忘截了 zookeeper双击zkServer.cmd tomcat和dubbo-admindubbo-admin须要github上下载，而后独自对dubbo-admin进行编译打war包，war包放到tomcat的webapps目录下，tomcat启动时会主动解压出文件夹，如下图 tomcat/bin目录执行startup.bat 胜利后浏览器如下关上 http://127.0.0.1:8080/dubbo-admin-2.5.8/ （我最后关上页面卡死，起初删除tomcat/log里的全副日志后失常了）用户名root 明码root 没有启动任何微服务所以上图各项都是空的。在Intellij IDEA运行两个微服务（cmd里java -jar 启动微服务jar包也能够，但调试批改代码不太不便）能够看到dubbo管理系统能够看见两个服务，一个是提供者，一个是消费者。外面能够查看名称，状态，日志，对排错挺有帮忙的。测试dubug浏览器输出登陆的url能够看到关上登录页面。到此一个微服务零碎的开发调试环境就实现了。如果只测试后端服务不关怀浏览器和app界面的性能，能够应用postman工具，间接发送url给服务端，查看返回的json数据等是否达到预期要求。

关于springboot:06SpringBoot工程下Spring-MVC技术的应用

Spring MVC 简介背景剖析在大型软件系统设计时，业务个别会绝对简单，如果所有业务实现的代码都纠缠在一起，会呈现逻辑不清晰、可读性差，保护艰难，改变一处就牵一发而动全身等问题。为了更好解决这个问题就有了咱们当初常说的分层架构设计。 MVC 是什么?MVC是一种软件架构设计思维,基于MVC架构将咱们的应用软件进行分层设计和实现,例如能够分为视图层(View),管制层(Controller),模型层(Model),通过这样的分层设计让咱们程序具备更好的灵活性和可可扩展性.因为这样能够将一个简单应用程序进行简化,实现各司其职,各尽所能.比拟适宜一个大型利用的开发. Spring MVC 概述Spring MVC是MVC设计思维在Spring框架中的一种实现，基于这样的思维spring框架设计了一些相干对象，用于更好的基于MVC架构解决申请和响应，其繁难架构如图所示：其中：1)DispatcherServlet是客户端所有申请解决的入口,负责申请转发。2)RequestMapping负责存储申请url到后端handler对象之间的映射。3)Handler 用于解决DispatcherServlet对象转发过去的申请数据。4)ViewResolver负责解决所有Handler对象响应后果中的view。 Spring MVC 疾速入门筹备工作第一步：创立我的项目module，根本信息如图所示：第二步：增加我的项目依赖(能够在module创立时，也能够创立后)，代码如下： Spring Web 依赖(提供了spring mvc反对并且会嵌入一个tomcat) <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId></dependency>Thymeleaf 依赖(提供了以html作为页面模板进行解析和操作的相干对象） <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId></dependency>第三步：启动我的项目检测控制台启动状态是否OK statics 目录剖析及利用statics 目录为springboot工程创立时增加了web依赖当前主动创立的目录，此目录中能够存储html、css、js、html等相干资源，这些资源能够在启动服务器当前，间接在浏览器进行拜访。例如：第一步：在statics目录下创立一个index.html页面，代码如下： <!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <title>Title</title></head><body> <h1>The First Html Page</h1></body></html>第二步：启动服务器并间接进行拜访测试,如图所示 templates 目录剖析及利用templates 目录为springboot工程创立时增加了thymeleaf依赖当前主动创立的目录，此目录中要存储一些html模板，这个模板页面不能间接通过浏览器url进行拜访，须要基于后端控制器，在办法中定义页面响应，例如：第一步：定义TemplateController及办法，代码如下： package com.cy.pj.health.controller;import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.RequestMapping;@Controllerpublic class TemplateController { @RequestMapping("/doHealth") public String doHealth(Model model) { model.addAttribute("username", "json"); model.addAttribute("state", true); return "default"; }}第二步：定义templates目录中定义模板页面health.html，代码如下： <!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <title>Title</title></head><body> <h1>The Default Template page</h1> <div> <ul> <li>username:[[${username}]]</li> <li>state:[[${state}]]</li> </ul> </div></body></html>第三步：启动服务进行拜访测试，如图所示： ...

关于springboot:SpringBoot-DB-系列Jooq-之新增记录使用姿势

【SpringBoot DB 系列】Jooq 之新增记录应用姿态接下来咱们开始进入 jooq 的增删改查的应用姿态系列，本篇将次要介绍如何利用 jooq 来实现增加数据  I. 我的项目搭建本我的项目借助SpringBoot 2.2.1.RELEASE + maven 3.5.3 + IDEA进行开发 1. 我的项目依赖对于如何创立一个 SpringBoot 的我的项目工程，不再本文的形容范畴内，如有趣味能够到文末的集体站点获取在这个示例工程中，咱们的选用 h2dabase 作为数据库（不便有趣味的小伙伴间接获取工程源码之后，间接测试体验），因而对应的 pom 外围依赖如下 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jooq</artifactId> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> </dependency></dependencies>2. 数据库初始化咱们借助jooq-codegen-maven插件来主动生成数据库相干的代码，对这一段逻辑感兴趣的小伙伴能够参考博文：【DB 系列】Jooq 代码主动生成后文中应用的表构造如下 DROP TABLE IF EXISTS poet;CREATE TABLE poet ( `id` int NOT NULL, `name` varchar(20) NOT NULL default '', CONSTRAINT pk_t_poet PRIMARY KEY (ID));DROP TABLE IF EXISTS poetry;CREATE TABLE poetry ( `id` int NOT NULL, `poet_id` int NOT NULL default '0', `title` varchar(128) not null default '', `content` varchar(128) not null default '', CONSTRAINT pk_t_poetry PRIMARY KEY (ID));3. 配置文件h2database 的连贯配置如 application.properties ...

关于springboot:SpringBoot工程中的myBatis框架的整合

~~~~spring中整合mybatismyBatis运行逻辑剖析一，在pom.xml文件中增加所需依赖：mysql驱动依赖<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope></dependency>spring jdbc 依赖<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jdbc</artifactId></dependency>mybatis starter 依赖<dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.3</version></dependency>二，在application.properties 配置文件中增加繁难配置连接池配置spring.datasource.url=jdbc:mysql://localhost:3306/dbgoods?serverTimezone=GMT%2B8&characterEncoding=utf8spring.datasource.username=rootspring.datasource.password=rootmybatis配置mybatis.mapper-locations=classpath:/mapper/*/*.xml

关于springboot:使用-Eureka-注册服务

【注】本文译自：https://www.tutorialspoint.co... 本文将带你深刻学习如何将 Spring Boot 微服务利用注册到 Eureka 服务器中。在注册利用前，请确保 Eureka Server 曾经运行在 8761 端口或者先构建 Eureka 服务器并运行起来。无关搭建 Eureka 服务器的信息，能够参考本系列教程的相干局部。首先，你须要在构建配置文件中退出以下依赖，以注册微服务到 Eureka 服务器。 Maven 用户能够加上上面的依赖到 pom.xml 文件： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-eureka</artifactId></dependency> Gradle 用户能够加上上面的依赖到 build.gradle 文件： compile('org.springframework.cloud:spring-cloud-starter-eureka') 当初，咱们须要在 Spring Boot 利用类文件中加上 @EnableEurekaClient 注解。@EnableEurekaClient 注解能够使你的 Spring Boot 利用作为 Eureka 客户端。主 Spring Boot 就用如下所示： package com.tutorialspoint.eurekaclient;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.cloud.netflix.eureka.EnableEurekaClient;@SpringBootApplication@EnableEurekaClientpublic class EurekaclientApplication { public static void main(String[] args) { SpringApplication.run(EurekaclientApplication.class, args); }} 要注册 Spring Boot 利用到 Eureka 服务器中，咱们要加上以下配置到 application.properties 或 application.yml 文件，并指定 Eureka 服务器的 URL。 application.yml 文件的代码如下： ...

关于springboot:05SpringBoot工程中的MyBatis框架的整合实现及原理分析

整合MyBatis的初步剖析概述Mybatis是一个优良的长久层框架，底层基于JDBC实现与数据库的交互。并在JDBC操作的根底上做了封装和优化，它借助灵便的SQL定制，参数及后果集的映射形式，更好的适应了以后互联网技术的倒退。Mybatis框架的简略利用架构如图所示：在当今的互联网利用中我的项目，mybatis框架通常会由spring框架进行资源整合，作为数据层技术实现数据交互操作。初步配置第一步：pom.xml文件中增加依赖 <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.1</version></dependency>第二步：application.properties 配置文件中增加繁难配置 mybatis.mapper-locations=classpath:/mapper/*/*.xml环境测试代码实现在src/test/java目录中增加测试类，对mybatis框架整合进行根本测试，代码如下： package com.cy.pj.goods.dao;import java.sql.Connection;import org.apache.ibatis.session.SqlSession;import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.test.context.SpringBootTest;@SpringBootTestpublic class MyBatisTests { @Autowired private SqlSession sqlSession; @Test public void testGetConnection() { Connection conn=sqlSession.getConnection(); System.out.println("connection="+conn); }}在SpringBoot脚手架工程中，Spring框架会基于MyBatis框架底层配置，创立SqlSessionFactory对象，而后再通过此工厂对象创立SqlSession，最初基于Springku框架为测试类注入SqlSession对象，接下来，咱们能够通过SqlSession对象实现与数据库的会话了。整合MyBatis业务代码实现及原理剖析业务形容基于SpringBoot脚手架工程对MyBatis框架的整合，实现对商品库中商品数据的查问业务。 API架构设计业务时序图剖析业务代码设计及实现测试代码的编写及运行测试运行过程中的BUG剖析业务层记录MyBatis底层SQL会话时长剖析及实现业务形容API架构设计业务时序图剖析业务代码设计及实现测试代码的编写及运行测试运行过程中的BUG剖析总结(Summary)

关于springboot:第四阶段-day925-Spring-Boot

1.Ajax增强1.1 Ajax特点应用ajax特点为: 部分刷新,异步响应.同步毛病: 如果进行了同步的申请,那么用户不能够做任何的操作,只能期待工作的实现. 用户的敌对性差. 1.2 对于Ajax调用阐明`<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%><%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><title>您好Springboot</title><script type="text/javascript" src="/js/jquery-3.4.1.min.js"></script><script type="text/javascript"> /** for语法1: for(let i=0;i<xxx.length;i++){ ..... } for语法2: index 代表下标 for(let index in data){ console.log("测试for循环") let user = data[index]; alert(user.name); } for语法3: user以后循环遍历的对象 for(let user of data){ console.log("for循环测试:"+user.name); } **/ $(function(){ $.ajax({ type : "get", url : "/findAjax", //dataType : "text/json/html/xml", //返回值类型 async : false, //敞开异步操作,改为同步的申请 success : function(data){ let trs = ""; for(let user of data){ let id = user.id; let name = user.name; let age = user.age; let sex = user.sex; trs += "<tr align='center'><td>"+id+"</td><td>"+name+"</td><td>"+age+"</td><td>"+sex+"</td></tr>" } $("#tab1").append(trs); }, error : function(){ alert("申请异样!!!!"); } }) //1. $.get(url,data,回调函数) //findAjax查问后端userList汇合信息. /* $.get("/findAjax",function(data){ $(data).foreach(function(index,user){ console.log(user); }) let trs = ""; for(let user of data){ let id = user.id; let name = user.name; let age = user.age; let sex = user.sex; trs += "<tr align='center'><td>"+id+"</td><td>"+name+"</td><td>"+age+"</td><td>"+sex+"</td></tr>" } $("#tab1").append(trs); }); */ });</script></head><body> <table id="tab1" border="1px" width="65%" align="center"> <tr> <td colspan="6" align="center"><h3>学生信息</h3></td> </tr> <tr> <th>编号</th> <th>姓名</th> <th>年龄</th> <th>性别</th> </tr> </table></body></html>` 京淘我的项目架构设计============ ...

关于springboot:Spring-Boot-高级用法

1.1 为属性赋值操作1.1.1 业务需要阐明为属性动静赋值： //动静获取ip和端口数据//@ResponseBody 作用1：将对象转换为JSON 作用2.如果返回值是String类型，则返回字符串自身作用3.个别客户端发动ajax申请时，采纳该注解返回数据，将不会执行视图解析器操作 @RestController // @Controller+@ResponseBodypublic class RedisController{private String host="192.168.156.112";private Integer port=8091;}@RequestMapping("/getMsg")public String getMsg(){return host+":"+port;}1.1.2 对于YML文件阐明YML文件语法： 1.key:（空格） value2.key与key之间有层级的缩进关系server: port:8091属性赋值操作，编辑属性时留神前缀，只有springboot启动该数据就会被写入内存中 key-value格局redis: host:192.168.156.113 port:6379 1.1.3为属性赋值操作@RestController public class RedisController{@Value("${redis.host}") //spel表达式private String host;@Value("${redis.port}")private Integer port;}@RequestMapping("/getMsg")public String getMsg(){return host+":"+port;}1.2 指定配置文件为属性赋值因为YML配置文件中的数据个别都是零碎级别的数据，所以个别的业务数据都会写到properties的配置文件中。 1.2.1 编辑properties配置文件#pro文件语法 1.key=value 2.不要增加多余的""号 3.key不要反复pro.redis.host=111.111.111.111pro.redid.port=63791.2.2 编辑RedisControllerpackage com.jt.controller;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.PropertySource; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController //动静的导入pro配置文件,交给spring容器进行加载. @PropertySource("classpath:/properties/redis.properties") public class RedisController { @Value("${redis.host}") //spel表达式 private String host; @Value("${redis.port}") private Integer port; @Value("${pro.redis.host}") private String proHost; @Value("${pro.redis.port}") private Integer proPort; //指定properties文件进行赋值操作. @RequestMapping("/getMsg") public String getMsg(){ //从yml配置文件中动静获取 return host + ":" + port; } @RequestMapping("/getPro") public String getPro(){ return proHost + ":" + proPort; } }1.3 环境切换业务阐明：因为开发时都是连贯公司本人的数据库/服务器等。把这个环境称之为“开发环境”。 ...

关于springboot:分布式架构

1 分布式架构设计1.1传统我的项目架构设计问题阐明:因为单体我的项目将所有的模块都写到了一起,未来如果其中一个模块呈现了问题,将导致整个我的项目不能失常的运行. 1.2分布式介绍因为传统我的项目导致各个模块之间的耦合性较高.所以须要采纳分布式的思维将我的项目进行拆分.核心理念: 化整为零将我的项目依照某些特定的规定进行拆分. 1.2.1依照功能模块拆分 1.2.2依照层级拆分 2分布式思维带来的问题2.1分布式思维jar包如何保护? 2.2分布式思维中工具api如何治理? 3 创立父级工程3.1创立我的项目一般maven我的项目 3.2编辑pom.xml文件<packaging>pom</packaging><parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.3.4.RELEASE</version> <relativePath/> </parent><properties> <java.version>1.8</java.version>  <skipTests>true</skipTests></properties><dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> <exclusions> <exclusion> <groupId>org.junit.vintage</groupId> <artifactId>junit-vintage-engine</artifactId> </exclusion> </exclusions> </dependency>  <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </dependency>  <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency>  <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency>  <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.2.0</version> </dependency>   <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> </dependency>  <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> </dependency>  <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> </dependency>  <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> </dependency>  <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> </dependency>      <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency>  <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> </dependency></dependencies></project> ...

关于springboot:Spring-Boot-整合SSMThymeleafShiroEhCache实现登录认证和授权功能

文 | 平哥日期 | 20200927 用于记录本人Spring Boot整合Shiro过程。官网有篇教程能够参考：Integrating Apache Shiro into Spring-Boot Applications 根本环境和工具 IDE: IntelliJ IDEA Maven: 3.6.0 JDK: 1.8 Step 1 搭建根底SSM环境1.1 创立Maven工程，增加SSM+Thymeleaf+Shiro依赖Step1 创立Maven工程：省略用IDEA增加Maven工厂我的项目步骤，这个默认大家都懂…… 提醒：新建我的项目后记得配置IDEA的Maven参数，改为本地本人装置的Maven Step2 增加Spring Boot父依赖、shiro依赖： <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.3.4.RELEASE</version></parent><dependencies><dependency><groupId>org.apache.shiro</groupId><artifactId>shiro-spring-boot-web-starter</artifactId><version>1.6.0</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-thymeleaf</artifactId></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.1.3</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.11</version></dependency></dependencies>1.2 配置application.yml中数据库信息spring:datasource:driver-class-name: com.mysql.cj.jdbc.Driverurl: jdbc:mysql://localhost:3306/shiro?characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8username: rootpassword: root1.3 编写MVC各层代码编写根本MVC各层包和目录以及相干代码： 1.4 编写Thymeleaf页面Spring Boot 整合Thymeleaf，无需进行任何配置，只需在resources文件夹下创立templates文件夹，在其中创立html文件，SpringMVC即可主动进行跳转: JS、css、图片等动态资源须放在static文件夹下对于公共页面的跳转能够利用门路变量创立一个专用的单元办法： // 公共页面跳转共用单元办法@RequestMapping("/{path}")public String getPage(@PathVariable String path){return path;}Step 2 整合Shiro，实现登录认证留神：相干依赖已在第一步导入，不在赘述。 2.1 配置application.yml在Spring Boot配置文件application.yml中配置Shiro的默认登录链接： shiro:loginUrl: /login2.2 编写自定义Realm类和Shiro配置类Step1 创立com.gcp.shiro包 ...

关于springboot:03基于IDEA创建SpringBoot项目并进行入门分析

SpringBoot 我的项目创立创立Module基于IDEA创立我的项目Module,模块名为04-springboot-start,组id和包名为com.cy,如图所示:填写module信息,如图所示:抉择我的项目module版本,临时不须要本人手动增加任何依赖,如图所示:填写Module名称,实现module创立,如图所示我的项目构造剖析我的项目Module创立好当前，其代码构造剖析，如图所示： SpringBoot 我的项目启动剖析启动入口SpringBoot 工程中由SpringBootApplication注解形容的类为启动入口类，例如： package com.cy;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplicationpublic class Application {//Application.class public static void main(String[] args) {//Main Thread SpringApplication.run(Application.class, args); }}启动过程概要剖析SpringBoot工程启动时其繁难初始化过程，如图所示：在启动过程中底层做了哪些事件，大抵形容如下：1)基于配置加载类(通过ClassLoader将指定地位的类读到内存->底层通过线程调用IO从磁盘读取到内存)。2)对类进行剖析(创立字节码对象-Class类型,通过反射获取器配置信息)。3)对于指定配置(例如由spring特定注解形容)的对象存储其配置信息(借助BeanDefinition对象存储)。4)基于BeanDefinition对象中class的配置构建类的实例(Bean对象),从进行bean对象的治理。 SpringBoot 疾速入门剖析业务形容在我的项目Module中定义一个类，类名为DefaultCache，而后将此类对象交给Spring创立并治理。最初通过单元测试对类的实例进行剖析。 API设计剖析基于业务形容，进行API及关系设计，如图所示：代码编写及运行基于业务及API设计，进行代码编写，其过程如下：第一步：定义DefaultCache类 package com.cy.pj.common.cache;import org.springframework.stereotype.Component;/** * @Component 注解形容的类，示意此类交给Spring框架治理。 */@Componentpublic class DefaultCache {}第二步：定义DefaultCacheTests单元测试类 package com.cy.pj.common.cache;import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Autowired;public class DefaultCacheTests { /** * @Autowired 注解形容的属性由spring框架依照肯定规定为其注入值（赋值） * 赋值过程是怎么的？ * 1)依赖查找？(请问查找规定是什么？) * 2)依赖注入？(须要借助什么技术?) */ @Autowired private DefaultCache defaultCache; @Test void testDefaultCache(){ System.out.println(defaultCache.toString()); //FAQ? defaultCache变量援用的对象是由谁创立的，存储到了哪里？bean pool }}第三步：运行单元测试类进行利用剖析启动运行单元测试办法，检测其输入后果，基于后果剖析：1)SpringBoot我的项目中Bean对象的构建。2)SpringBoot我的项目中Bean对象的获取。 ...

关于springboot:解决Autowired自动装配错误

勾销图中Autowiring for bean class 的勾选.

关于springboot:idea-spring-boot启动不加载resources资源文件

idea工具不加载spring boot我的项目中的resources资源目录里的文件，如下图所示：起因是IDEA设置问题，正确的设置如下：file-->settings，全副选中即可。

关于springboot:SpringBoot中注解

Spring boot是一个脚手架，构建于Spring框架(Framework)根底之上，基于疾速构建理念，提供了主动配置性能，可实现其开箱即用个性（创立完一个根本的我的项目当前，可零配置或者大量配置即可运行咱们的我的项目），其外围次要有如下几个方面：▪ 起步依赖(Starter Dependency)-我的项目创立时底层帮你关联依赖。▪ 主动配置(Auto Configuration)。▪ 健康检查(Actator)-监控。………………………………………………………………………………………………………………………………………………………… @SpringBootApplication此注解形容此类是启动类 @Component注解的作用就是标记,示意将此类标记为Spring容器中的一个Bean。是Spring中用于形容Bean类的一个注解。用于通知Spring这个类的实例由Spring创立，当此对象由Spring创立和治理时，默认会将对象存储到池（Bean池）中。 @Service是一个非凡的@Component 是一个业务层对象，后续会在此对象中执行外围业务、扩大业务 @Mapper该注解是用于数据层用于通知Spring框架此接口的实现由mybatis创立，并将其实现类对象存储到spring容器@SpringBootTest//此注解形容此类是SpringBoot工程中的单元测试类示意这个测试类交给spring去治理 @Autowired此注解通知spring框架运行时为此属性注入一个值能够：形容属性 set办法（通常配合无参构造方法应用）构造方法（能够省略） @Qualifier("cd")通知spring为咱们注入的是容器中的cd这个bean对象要和@Autowired一起配合应用前提是bean池中有多个bean 能够：形容属性 set办法切记不能够写在构造方法下面须要写在构造方法的参数里 @Lazy此注解的作用是提早加载，通知spring框架，用的时候再创立实例 @Scope("prototype")每次从spring容器中去对象时，都会创立多实例 @Scope("singleton")该注解默认就是单例作用（这个类的实例在一个spring容器中默认只有一份） @PostConstruct该注解形容的办法会在对象构建当前执行，用于执行一些初始化操作 @PreDestroy该注解形容的是在单例队象销毁之前会执行此办法，spring容器在销毁之前会先将容器（Bean池）中的对象进行移除，在移除对象时，如果对象中定义了生命周期销毁办法，此时还会调用生命周期销毁办法 @Controller用于标记在一个类上，应用它标记的类就是一个SpringMVC Controller 对象。散发处理器将会扫描应用了该注解的类的办法。艰深来说，被Controller标记的类就是一个控制器，这个类中的办法，就是相应的动作。 @ControllerAdvice标记该类是全局异样解决类 @ExceptionHandler(RuntimeException.class)标记该办法是一个异样解决办法 @RequestMapping是一个用来解决申请地址映射的注解，可用于类或办法上。用于类上，示意类中的所有响应申请的办法都是以该地址作为父门路。 @PropertySource("classpath:/*")是加载指定的配置文件 @Accessors(chain = true)链式加载 eg：能够这样为属性赋值user.setId(10).setName("AAA"); @GetMapping("/page/{moduleName}")等同于@RequestMapping(value = "/page/{moduleName}",method = RequestMethod.GET) …………………………………………………………………………………………………………………………………………………………… 配置文件中敞开Banner显示:spring.main.banner-mode=off JVM参数-最小堆：-Xms5m 最大堆：-Xmx5m 跟踪运行配置：Arguments参数 VM arguments 参数: -XX:+TraceClassLoading任何一个我的项目都有一个启动入口，在springboot中的启动类须要@SpringBootApplication注解进行形容，并且在类中定义一个main办法，main办法在运行时会读取配置文件，并加载指定资源，而后进行初始化操作同时须要留神的是类（测试类）要写在启动类（启动测试类）所在的包或子包下1）SpringBoot我的项目中配置文件起源？a)SpringBoot 官网定义（个别为一些根底配置）例如spring.factoriesb)第三方定义(日志零碎-log4j、xml……)c)咱们本人定义2）SpringBoot我的项目中的资源加载?(资源能够了解为咱们的class类）-把资源从磁盘读取到内存a)JDK类文件b)Spring类文件c)本人定义的类文件3）Spring中的我的项目资源初始化？a)构建实例对象b)基于对象存储数据（例如配置信息，默认值）

关于springboot:Spring-Boot-基础

1 Spring Boot整合连接池1.1整合HikariCP连接池在pom.xml文件中增加依赖1.mysql数据库驱动依赖 <dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency>2.spring对象jdbc反对 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency>1.2配置连接池关上application.properties配置文件，增加如下内容。 spring.datasource.url=jdbc:mysql:///dbgoods?serverTimezone=GMT%2B8&characterEncoding=utf8spring.datasource.username=rootspring.datasource.password=root1.3单元测试(测试包中写)@SpringBootTestpublic class DataSourceTests { @Autowiredprivate DataSource dataSource; @Testpublic void testConnection() throws Exception{System.out.println(dataSource.getConnection());}}2 Spring Boot整合MyBatis框架MyBatis是一个优良的长久层框架，底层基于JDBC实现与数据库的交互。并在JDBC操作的根底上做了封装和优化，它借助灵便的SQL定制，参数及后果集的映射形式，更好的适应了以后互联网技术的倒退. 2.1初始配置2.1.1增加mybatis启动依赖<dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.1.3</version></dependency>2.1.2MyBatis繁难配置(可选，临时能够不配)mybatis.configuration.default-statement-timeout=30mybatis.configuration.map-underscore-to-camel-case=true2.1.3配置mybatis中的sql日志的输入：(com.cy为我的项目的根包)logging.level.com.cy=DEBUG3 Spring Boot 整合SpringMVC利用3.1概述MVC是软件工程中的一种软件架构模式，基于此模式把软件系统分为3个根本局部：模型(Model)、视图(View)、和控制器(Controller)。目标是通过这样的设计使程序结构更加简洁、直观，升高问题的复杂度。！视图(View)-UI设计人员进行图形界面设计，负责实现与用户交互！控制器(Controller)-负责获取申请，解决申请，响应后果！模型(Model)-实现业务逻辑，数据逻辑实现 3.2初始配置增加Spring Web依赖.Web依赖(提供了Spring MVC外围API，同时会嵌入一个Tomcat服务器) <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>Thymeleaf依赖(提供了一个视图解析器对象以及数据绑定机制). <dependency><groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId></dependency>3.2.1配置spring mvc外围对象在application.properties文件中增加图解析器配置（如果没有配置也会默认配置，在默认配置中prefix默认值为classpath:/templates/,后缀默认为.html）。 spring.thymeleaf.prefix=classpath:/templates/pages/spring.thymeleaf.suffix=.html阐明:要基于配置在src/main/resources目录下创立templates/pages目录

关于springboot:springbootidea属性赋值

为指定配置文件进行赋值1.3 环境切换业务阐明:因为开发时都是链接公司本人的数据库/服务器等.把这个环境称之为"开发环境."当开发实现之后须要进行上线部署,则须要链接"生产环境"如果频繁的切换环境,则导致我的项目因为批改谬误,导致问题的产生.我的项目优化: 是否提供一种策略.简化上述操作的开发过程. 1.2 指定配置文件为属性赋值阐明: 因为繁多配制文件配置多了就完了所以新建一个新的配制文件； 1.2.1 编辑properties配置文件

关于springboot:个人学习系列-Spring-Boot-整合-UReport2

工作中总是须要生成各种各样的报表，麻烦的很。最近发现了一个UReport2，据说能够实现简单的中国式报表，有点小冲动。。。1. 新建springboot我的项目1.1 pom.xml<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId></dependency><dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope></dependency><dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId></dependency><dependency> <groupId>com.bstek.ureport</groupId> <artifactId>ureport2-console</artifactId> <version>2.2.9</version></dependency>1.2 application.ymlserver: port: 8888# 数据库链接数据源配置spring: datasource: driver-class-name: com.mysql.jdbc.Driver url: jdbc:mysql://IP地址:3306/数据库名称?useSSL=false&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&transformedBitIsBoolean=true&tinyInt1isBit=false&serverTimezone=GMT%2B8 username: 数据库用户名 password: 数据库明码1.3 编写config代码类，用于配置UReport2/** * springboot实体类配置 * context.xml为UReport2的配置文件 * @author zhouzhaodong */@ImportResource("classpath:context.xml")@Configurationpublic class BeanConfig { @Bean public ServletRegistrationBean<Servlet> ureport2Servlet() { return new ServletRegistrationBean<>(new UReportServlet(), "/ureport/*"); }}1.4 新建UReport2的配置文件context.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <import resource="classpath:ureport-console-context.xml"/>  <bean id="propertyConfigurer" parent="ureport.props"> <property name="location" value="classpath:context.properties"/> </bean></beans>1.5 新建context.properties这里我次要是在这里定义UReport2中提供的默认基于文件系统的报表存储目录： # 用于定义UReport2中提供的默认基于文件系统的报表存储目录ureport.fileStoreDir=src/main/resources/ureportfiles这里须要留神的是，咱们设置在ureportfiles文件夹上面存储报表，这个文件夹须要咱们手动创立，否则无奈保留。。。 1.6 这里须要定义内置数据源这里须要留神的是数据源连贯形式有三种： ...

关于springboot:SpringBoot-环境切换-属性赋值

一、切换环境业务阐明:因为开发时都是链接公司本人的数据库/服务器等.把这个环境称之为"开发环境."当开发实现之后须要进行上线部署,则须要链接"生产环境"如果频繁的切换环境,则导致我的项目因为批改谬误,导致问题的产生. 1.须要将咱们的环境一分为二 ---其中spring.profiles.active 是切换开发环境和生产环境 2.指定环境名称 spring.profiles 二、属性赋值办法一：在yml中自定义属性其取值形式为办法二：在resources目录下自定义一个*.properties文件（后缀名必须是properties文件）定义属性其取值形式为并且在类上要加有@PropertySource("classpath:/*.properties")注解，指定其要加载的文件门路扩大阐明:如果须要应用lombok工具就必须提前装置插件.如果在上线的时候Linux零碎中,是否须要提前装置lombok插件?? 不须要装置. Lombok插件在编译期无效，将.java文件编译成.class文件会动静的增加到.class文件中 Linux上线部署时运行的.jar文件 jar包中蕴含.class文件

关于springboot:基于SpirngBoot的企业级后台管理框架Guns完整解析

小Hub领读：guns这个我的项目置信很多人都晓得，不晓得你们有没残缺读过呢，明天一起跟着小Hub来学习下哈。一共几个次要模块比拟重要： map + warpper模式Api数据传输平安数据范畴限定简介Guns基于SpringBoot 2，致力于做更简洁的后盾管理系统。Guns我的项目代码简洁，正文丰盛，上手容易，同时Guns蕴含许多根底模块(用户治理，角色治理，部门治理，字典治理等10个模块)，能够间接作为一个后盾管理系统的脚手架! 官网：https://www.stylefeng.cn 视频解说：https://www.bilibili.com/video/BV1P5411j7yA/ 本次解读版本：tag-v4.2版本，因为5.0后的我的项目都是maven单我的项目，外围类都封装到jar中了，所以学习的话最好应用v4.2的最初一版本maven多模块我的项目学习。 https://gitee.com/stylefeng/guns/tree/v4.2/ 我的项目特点基于SpringBoot,简化了大量我的项目配置和maven依赖,让您更专一于业务开发,独特的分包形式,代码多而不乱。欠缺的日志记录体系，可记录登录日志，业务操作日志(可记录操作前和操作后的数据)，异样日志到数据库，通过@BussinessLog注解和LogObjectHolder.me().set()办法，业务操作日志可具体记录哪个用户，执行了哪些业务，批改了哪些数据，并且日志记录为异步执行，详情请见@BussinessLog注解和LogObjectHolder,LogManager,LogAop类。利用beetl模板引擎对前台页面进行封装和拆分，使臃肿的html代码变得简洁，更加易保护。对罕用js插件进行二次封装，使js代码变得简洁，更加易保护，具体请见webapp/static/js/common文件夹内js代码。利用ehcache框架对常常调用的查问进行缓存，晋升运行速度，具体请见ConstantFactory类中@Cacheable标记的办法。controller层采纳map + warpper形式的返回后果，返回给前端更为灵便的数据，具体参见com.stylefeng.guns.modular.system.warpper包中具体类。简略可用的代码生成体系，通过SimpleTemplateEngine可生成带有主页跳转和增删改查的通用控制器、html页面以及相干的js，还能够生成Service和Dao，并且这些生成项都为可选的，通过ContextConfig下的一些列xxxSwitch开关,可灵便管制生成模板代码，让您把工夫放在真正的业务上。控制器层对立的异样拦挡机制,利用@ControllerAdvice对立对异样拦挡,具体见com.stylefeng.guns.core.aop.GlobalExceptionHandler类。技术选型springbootmybatis plusshirobeetlehcachejwt模块剖析学习一个我的项目就是学习我的项目的亮点中央，在剖析guns的过程中，有些中央值得咱们学习，上面咱们一一来剖析： map + warpper模式拜访后盾的用户列表时候，咱们通常须要去查问用户表，然而用户表外面有些外键，比方角色信息、部门信息等。因而有时候咱们查问列表时候个别在mapper中关联查问，而后失去记录。官网介绍： map+warpper形式即为把controller层的返回后果应用BeanKit工具类把原有bean转化为Map的的模式(或者原有bean间接是map的模式)，再用独自写的一个包装类再包装一次这个map，使外面的参数更加具体，更加有含意，上面举一个例子，例如，在返回给前台一个性别时，数据库查出来1是男2是女，如果间接返回给前台，那么前台显示的时候还须要减少一次判断，并且前后端拆散开发时又减少了一次交换和文档的老本，然而采纳warpper包装的模式，能够间接把返回后果包装一下，例如动静减少一个字段sexName间接返回给前台性别的中文名称即可。 guns我的项目中，作者说独创了一种map+warpper模式。咱们来看下是如何实现的。看看下UserController的代码： /** * 查问管理员列表 */@RequestMapping("/list")@Permission@ResponseBodypublic Object list(@RequestParam(required = false) String name , @RequestParam(required = false) String beginTime , @RequestParam(required = false) String endTime , @RequestParam(required = false) Integer deptid) { if (ShiroKit.isAdmin()) { List<Map<String, Object>> users = userService.selectUsers(null, name, beginTime, endTime, deptid); return new UserWarpper(users).warp(); } else { DataScope dataScope = new DataScope(ShiroKit.getDeptDataScope()); List<Map<String, Object>> users = userService.selectUsers(dataScope, name, beginTime, endTime, deptid); return new UserWarpper(users).warp(); }}userService.selectUsers中只是一个单表的查问操作，没有关联其余表，因而查问进去的后果中有些字段须要手动转换，比方sex、roleId等，因而作者定义了一个UserWarpper，用来转换这些非凡字段，比方sex存的0转成男，roleId查库之后转成角色名称等。 ...

关于springboot:Bean对象为什么要交给Spring框架管理

Spring是一个资源管理整合框架，通过spring可将很多资源（本人写的对象或第三方提供的对象，例如连接池等）整合在一起，而后进行迷信的利用，以便更好地对外提供服务，spring框架能够由它治理的对象（Bean）提供懒加载策略（对象临时用不到，则无需加载和实例化），作用域（例如singleton频繁用时能够思考内存中只有一份，prototype应用次数少时，能够用时创立，不必时销毁），申明周期办法（更好实现对象的初始化和资源销毁），以实现对象对于系统资源的无效应用。同时Spring框架还能够基于用户设计治理的对象与对象的依赖关系，以升高对象与对象之间的间接耦合，进步程序的克维护性和可扩展性。 @Lasy注解用于形容类，其目标是通知spring框架此类反对提早加载，通常会配合单例作用域应用。 @Scope是Spring中用于定义Bean对象作用域的一个注解，其罕用的值有singleton（整个内存有一份Bean实例，此实例创立当前，生命周期会spring框架治理），prototype（每次获取都会创立新实例，此实例会在须要时创立与lazy个性无关，这个实例创立当前，不会交给spring治理，spring能够对其初始化，但不负责销毁。）等 @PostConstruct注解用于形容bean对象生命周期办法中的初始化办法，此办法会在对象的构造方法之后执行（是对象创立当前的初始化）。 @PreDestroy注解用于形容Bean对象生命周期办法中的销毁办法，此办法会在对象销毁之前执行（当作用域为prototype时，此办法不会执行）。

关于springboot:springboot的注解加载过程吧

SpringBoot程序启动加载过程 4.3.1元注解阐明:@Target(ElementType.TYPE) 对哪个元素无效对类无效@Retention(RetentionPolicy.RUNTIME) 什么时候起作用运行期无效@Documented 是否反对生成文档@Inherited 该注解是否能够被继承. 4.3.2 SpringBootConfiguration阐明作用:标识主启动类是一个大型的配置文件,启动时会加载所有的小的配置文件. @Configuration: 示意该类是一个配置类. `@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Configurationpublic @interface SpringBootConfiguration {.....}` * 1* 2* 3* 4* 54.3.3 excludeFilters 阐明阐明: 在springboot容器启动时,不须要加载某些过滤器.因为parent标签中定义了所有的关联的jar包文件信息.则启动时有可能导致意外的产生,所有须要提前剔除. @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) 4.3.4 @AutoConfigurationPackage阐明: 当程序启动时,会依据主启动类的包门路,扫描其子孙包,所以springboot当前写代码时应该在其子孙包下编辑. 4.3.5 AutoConfigurationImportSelector阐明:该配置中外部集成了所有的SpringBoot中的选择器.这些选择器的次要的工作就是查看是否有本人选择器所治理的启动项的配置. 如果发现该启动项,那么选择器就会执行该启动项,从而实现了开箱即用的操

关于springboot:第四阶段-day922-Spring-Boot

京淘我的项目概述 SpringBoot 启动原理阐明4.1 需要阐明 1.SpringBoot启动是如何流转的. 2.什么叫做开箱即用,springBoot中如何实现开箱即用的. 4.2 "开箱即用"阐明如果须要引入第三方的"工具/性能",只须要通过大量的配置/或者不做任何配置.则就能够应用该性能4.3 对于启动项的阐明  <dependency> <groupId>org.springframework.boot</groupId>  <artifactId>spring-boot-starter-web</artifactId> </dependency>4.3 SpringBoot程序启动加载过程@SpringBootApplication注解是一个组合注解，其中包含：@SpringBootConfiguration、@EnableAutoCOnfiguration、@ComponentScan@SpringBootConfiguration继承自@Configuration，二者性能统一，标注以后类是配置类，并会将以后类内声名的以@Bean注解标注的办法实例纳入Spring容器中，实例名就是办法名。@ComponentScan的作用是主动扫描并加载符合条件的的组件或Bean定义，最终将这些Bean加载到容器中。咱们能够通过basePackages属性指定扫描的范畴，如果不指定，默认扫描以后包及其子包上面的类。@EnableAutoConfiguration是借助@Import将所有合乎主动配置条件的Bean加载到IOC容器。 4.3.1元注解阐明:@Target(ElementType.TYPE) 对哪个元素无效对类无效@Retention(RetentionPolicy.RUNTIME) 什么时候起作用运行期无效@Documented 是否反对生成文档@Inherited 该注解是否能够被继承.4.3.2 SpringBootConfiguration阐明作用:标识主启动类是一个大型的配置文件,启动时会加载所有的小的配置文件.@Configuration: 示意该类是一个配置类.`@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Configurationpublic @interface SpringBootConfiguration {.....}` * 1* 2* 3* 4* 5@EnableAutoConfiguration 阐明注解启用主动配置，其能够帮忙 SpringBoot 利用将所有符合条件的 @Configuration 配置都加载到以后 IoC 容器之中4.3.3 excludeFilters 阐明阐明: 在springboot容器启动时,不须要加载某些过滤器.因为parent标签中定义了所有的关联的jar包文件信息.则启动时有可能导致意外的产生,所有须要提前剔除. @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })4.3.4 @AutoConfigurationPackage阐明: 当程序启动时,会依据主启动类的包门路,扫描其子孙包,所以springboot当前写代码时应该在其子孙包下编辑.4.3.5 AutoConfigurationImportSelector阐明:该配置中外部集成了所有的SpringBoot中的选择器.这些选择器的次要的工作就是**查看是否有本人选择器所治理的启动项的配置**. 如果发现该启动项,那么选择器就会执行该启动项,从而实现了开箱即用的操作.

关于springboot:个人学习系列-Spring-Boot-整合-H2

每当有我的项目须要拜访数据库的时候总是很苦恼，因为无论哪个数据库都比拟宏大，运行起来也比拟耗内存，有没有简略能够随我的项目启动的数据库吗？有，H2来了。。。1. 搭建Spirng Boot我的项目如果启动出现异常，就将中文正文去掉再启动即可。 1.1 pom.xml<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId></dependency><dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <scope>runtime</scope></dependency><dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <optional>true</optional></dependency><dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId></dependency><dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId></dependency>1.2 application.ymlserver: port: 8888 # 端口号spring: jpa: show-sql: true # 启用SQL语句的日志记录 hibernate: ddl-auto: update # 设置ddl模式 datasource: driver-class-name: org.h2.Driver# url： jdbc:h2:mem:h2 # 配置h2数据库连贯地址（这里应用的是内存，下次启动数据就不存在了） url: jdbc:h2:file:./db/h2;AUTO_SERVER=TRUE # 配置h2数据库连贯地址（这里应用的是本地存储形式，下次启动数据还存在） username: root # 配置数据库用户名 password: 123456 # 配置数据库明码 h2: console: path: /h2 # 进行该配置，你就能够通过YOUR_URL/h2拜访h2 web consloe。YOUR_URL是你程序的拜访URl enabled: true # 配置程序开启时就会启动h2 web consloe settings: web-allow-others: true # 配置h2的近程拜访1.3 新建User实体类/** * 实体类 * @author zhouzhaodong */@Entity@Table(name="user")public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; @Column private String name; @Column private String phone; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; }}1.4 新建UserDao类/** * dao * @author zhouzhaodong */public interface UserDao extends JpaRepository<User, Integer> {}1.5 新建UserController管制层/** * 管制层 * @author zhouzhaodong */@RestControllerpublic class UserController { @Resource UserDao userDao; @RequestMapping("/findById") public Object findById(Integer id){ return userDao.findById(id); } @RequestMapping("/insert") public void insert(User user){ userDao.save(user); } @RequestMapping("/delete") public void delete(Integer id){ userDao.deleteById(id); }}2. 测试2.1 启动我的项目会发现db长久化在我的项目外部了： ...

关于springboot:个人学习系列-Spring-Boot整合screw实现数据库文档自动生成

有时候数据库文档须要整顿，可是只能手动的复制粘贴，心中一万只草泥马奔流而过。。。screw简洁好用的数据库表构造文档生成工具。 1. 创立我的项目1.1 pom.xml<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope></dependency><dependency> <groupId>org.freemarker</groupId> <artifactId>freemarker</artifactId> <version>2.3.30</version></dependency><dependency> <groupId>cn.smallbun.screw</groupId> <artifactId>screw-core</artifactId> <version>1.0.5</version></dependency>1.2 新建工具类DocumentConfig.java/** * 文档生成 */ static void documentGeneration() { //数据源 HikariConfig hikariConfig = new HikariConfig(); hikariConfig.setDriverClassName("com.mysql.cj.jdbc.Driver"); hikariConfig.setJdbcUrl("jdbc:mysql://IP地址:3306/数据库名称"); hikariConfig.setUsername("用户名"); hikariConfig.setPassword("明码"); //设置能够获取tables remarks信息 hikariConfig.addDataSourceProperty("useInformationSchema", "true"); hikariConfig.setMinimumIdle(2); hikariConfig.setMaximumPoolSize(5); DataSource dataSource = new HikariDataSource(hikariConfig); //生成配置 EngineConfig engineConfig = EngineConfig.builder() //生成文件门路 .fileOutputDir("D:\\") //关上目录 .openOutputDir(true) //文件类型 .fileType(EngineFileType.HTML) //生成模板实现 .produceType(EngineTemplateType.freemarker) //自定义文件名称 .fileName("test数据库").build(); //疏忽表 ArrayList<String> ignoreTableName = new ArrayList<>(); ignoreTableName.add("test_user"); ignoreTableName.add("test_group"); //疏忽表前缀 ArrayList<String> ignorePrefix = new ArrayList<>(); ignorePrefix.add("test_"); //疏忽表后缀 ArrayList<String> ignoreSuffix = new ArrayList<>(); ignoreSuffix.add("_test"); ProcessConfig processConfig = ProcessConfig.builder() //指定生成逻辑、当存在指定表、指定表前缀、指定表后缀时，将生成指定表，其余表不生成、并跳过疏忽表配置 //依据名称指定表生成 .designatedTableName(new ArrayList<>()) //依据表前缀生成 .designatedTablePrefix(new ArrayList<>()) //依据表后缀生成 .designatedTableSuffix(new ArrayList<>()) //疏忽表名 .ignoreTableName(ignoreTableName) //疏忽表前缀 .ignoreTablePrefix(ignorePrefix) //疏忽表后缀 .ignoreTableSuffix(ignoreSuffix).build(); //配置 Configuration config = Configuration.builder() //版本 .version("1.0.0") //形容 .description("数据库设计文档生成") //数据源 .dataSource(dataSource) //生成配置 .engineConfig(engineConfig) //生成配置 .produceConfig(processConfig) .build(); //执行生成 new DocumentationExecute(config).execute(); }1.3 运行该办法 ...

关于springboot:大概流程项目中的乱码是如何解决的

关于springboot:个人学习系列-Spring-Boot集成DelayQueue实现订单到期自动取消

最近在思考购物网站上的未领取订单到期主动勾销是怎么实现的，发现了一个DelayQueue队列能够实现，所以来整顿一下。。。DelayQueuejava提早队列提供了在指定工夫能力获取队列元素的性能，队列头元素是最靠近过期的元素。没有过期元素的话，应用poll()办法会返回null值，超时断定是通过getDelay(TimeUnit.NANOSECONDS)办法的返回值小于等于0来判断。 1. 新建Spring Boot我的项目1.1 pom.xml<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId></dependency><dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId></dependency><dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.4.2</version></dependency>1.2 application.ymlserver: port: 8888order: isStarted: 1 # 是否开启主动勾销性能（0敞开，1开启）1.3 新建Order订单类/** * 订单类 * @author zhouzhaodong */public class Order implements Delayed { /** * 订单号 */ private String orderNo; /** * 用户id */ private String userId; /** * 订单状态（0待领取，1已领取，2已勾销） */ private Integer status; /** * 订单创立工夫 */ private Date createTime; /** * 订单勾销工夫 */ private Date cancelTime; public String getOrderNo() { return orderNo; } public void setOrderNo(String orderNo) { this.orderNo = orderNo; } public String getUserId() { return userId; } public void setUserId(String userId) { this.userId = userId; } public Integer getStatus() { return status; } public void setStatus(Integer status) { this.status = status; } public Date getCreateTime() { return createTime; } public void setCreateTime(Date createTime) { this.createTime = createTime; } public Date getCancelTime() { return cancelTime; } public void setCancelTime(Date cancelTime) { this.cancelTime = cancelTime; } public Order(String orderNo, String userId, Integer status, Date createTime, Date cancelTime) { this.orderNo = orderNo; this.userId = userId; this.status = status; this.createTime = createTime; this.cancelTime = cancelTime; } @Override public String toString() { return "Order{" + "orderNo='" + orderNo + '\'' + ", userId='" + userId + '\'' + ", status=" + status + ", createTime=" + createTime + ", cancelTime=" + cancelTime + '}'; } /** * 取得延迟时间，用过期工夫-以后工夫，工夫单位须要对立 * @param unit * @return */ @Override public long getDelay(TimeUnit unit) { //上面用到unit.convert()办法，其实在这个小场景不须要用到，只是学习一下如何应用罢了 return unit.convert(cancelTime.getTime() - System.currentTimeMillis(), TimeUnit.MILLISECONDS); } /** * 用于提早队列外部比拟排序，以后工夫的延迟时间 - 比拟对象的延迟时间 * @param o * @return */ @Override public int compareTo(Delayed o) { //这里依据勾销工夫来比拟，如果勾销工夫小的，就会优先被队列提取进去 return this.getCancelTime().compareTo(((Order) o).getCancelTime()); }}1.4 新建CancelOrderService/** * 勾销订单service类 * @author zhouzhaodong */public interface CancelOrderService { /** * 勾销订单 */ void cancelOrder(); /** * 获取队列 * @return */ DelayQueue<Order> getOrder();}1.5 新建servie实现类/** * 勾销订单实现类 * * @author zhouzhaodong */@Servicepublic class CancelOrderServiceImpl implements CancelOrderService { /** * 是否开启主动勾销性能 */ @Value("${order.isStarted}") private int isStarted; /** * 提早队列，用来寄存订单对象 */ DelayQueue<Order> queue = new DelayQueue<>(); @Resource private ThreadPoolTaskExecutor executorService; @Override public void cancelOrder() { //新建一个线程，用来模仿定时勾销订单job executorService.submit(()->{ try { System.out.println("开启主动勾销订单job,以后工夫：" + DateUtil.date()); while (isStarted == 1) { try { Order order = queue.take(); order.setStatus(2); System.out.println("订单：" + order.getOrderNo() + "付款超时，主动勾销，以后工夫：" + DateUtil.date()); } catch (InterruptedException e) { e.printStackTrace(); } } } catch (Exception e) { e.printStackTrace(); } }); } @Override public DelayQueue<Order> getOrder(){ executorService.submit(()->{ try { Date date = DateUtil.date(); queue.add(new Order("SO001", "001", 0, date, DateUtil.offset(date, DateField.SECOND, 3))); queue.add(new Order("SO002", "002", 0, DateUtil.offset(date, DateField.SECOND, 3), DateUtil.offset(date, DateField.SECOND, 6))); queue.add(new Order("SO003", "003", 0, DateUtil.offset(date, DateField.SECOND, 6), DateUtil.offset(date, DateField.SECOND, 9))); queue.add(new Order("SO004", "004", 0, DateUtil.offset(date, DateField.SECOND, 9), DateUtil.offset(date, DateField.SECOND, 12))); queue.add(new Order("SO005", "005", 0, DateUtil.offset(date, DateField.SECOND, 12), DateUtil.offset(date, DateField.SECOND, 15))); queue.add(new Order("SO006", "006", 0, DateUtil.offset(date, DateField.SECOND, 15), DateUtil.offset(date, DateField.SECOND, 18))); } catch (Exception e) { e.printStackTrace(); } }); return queue; }}1.6 新建controller/** * 控制器 * @author zhouzhaodong */@RestControllerpublic class CancelOrderController { @Resource CancelOrderService cancelOrderService; @RequestMapping("/") public void cancelOrder(){ cancelOrderService.getOrder(); cancelOrderService.cancelOrder(); } @RequestMapping("/queue") public void getOrder(){ cancelOrderService.getOrder(); } }2. 测试2.1 启动我的项目，拜访localhost:8888/ ...

关于springboot:3映射控制层dao修改时间状态层活动页面

映射文件代码的应用 <?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.cy.pj.activity.dao.ActivityDao">    <insert id="insertObject" useGeneratedKeys="true" keyProperty="id"> insert into tb_activity(title,category,startTime,endTime,remark,state) values(#{title},#{category},#{startTime},#{endTime},#{remark},1) </insert></mapper>dao层 //依据id来修工夫的状态的事件 @Update("update tb_activity set state=0 where id=#{id}") int updateState(Integer id);//批改工夫状态,默认将其设置为有效管制层管制层管制层重要的事件敲三遍 package com.cy.pj.activity.controller;import java.util.List;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;import com.cy.pj.activity.pojo.Activity;import com.cy.pj.activity.service.ActivityService;@Controller@RequestMapping("goods")public class ActivityController { @Autowired//这个是返回页面 private ActivityService activityService; @RequestMapping("doinsertObject") //以字符返回进来值 //传参数 @ResponseBody//以字符串的模式返回给框 public String doinsertObject(Activity entity) { activityService.saveObject(entity); //return "activity";//这样返回,刷新的是整个页面所以最好异步加载 return "增加胜利"; } @RequestMapping("doActivityUI") public String doActivityUI(){ return "activity";//返回html的 } @RequestMapping("doFindActivitys")//这个是返回数据 //这个是查看数据库里的所有数据把数据发送给服务端的代码； @ResponseBody//通知spring框架将返回值对象转换为json格局字符串进行返回 public List<Activity> doFindActivitys(){ List<Activity> list = activityService.findActivitys(); return list;//返回一个list汇合; }}

关于springboot:2活动页面imp代码

package com.cy.pj.activity.service.impl;import java.util.List;import java.util.Timer;import java.util.TimerTask;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import com.cy.pj.activity.dao.ActivityDao;import com.cy.pj.activity.pojo.Activity;import com.cy.pj.activity.service.ActivityService;@Service // 扩占性能public class ActivityServiceImpl implements ActivityService { @Autowired private ActivityDao activityDao; @Override public List<Activity> findActivitys() { // TODO Auto-generated method stub return activityDao.findActivitys(); } @Override public int saveObject(Activity entity) { // TODO Auto-generated method stub int rows= activityDao.insertObject(entity); // 心愿工夫到了(endTime)主动批改活动状态 // 解决方案:基于任务调度去实现任务调度-基于工夫的设计主动执行工作） // 1借助java中的Timer对象去实现 // ###工作###调度工作###调度工作###调度工作###调度任务调度任务调度任务调度任务调度 Timer timer = new Timer();// 此对象创立时会在底层启动一个线程。通过此县城对工夫进行监控 // 外面的类型是timerTask类型所以要newTimerTask timer.schedule(new TimerTask() { @Override public void run() { // 此地位批改流动的状态信息 System.out.println("开始任务调度的执行"); //通过映射获取到了id的值间接getId就行了 activityDao.updateState(entity.getId()); timer.cancel();//完结调度工作//cancel砍搜 } }, entity.getEndTime());// 通过entity调用getEndTime办法 // 在此地位批改流动的状态信息 // 2借助java线程池中的任务调度对象去实现(ScheduledExecutorService)去实现 // 3借助第三方框架去实现 return rows;// 间接返回这个值了 } // ###工作###调度工作###调度工作###调度工作###调度任务调度任务调度任务调度任务调度}

关于springboot:Spring-AOP

Spring AOP简介1.1 AOP概述AOP是一种设计思维，是软件设计畛域中的面向切面编程，它是面向对象编程（OOP）的一种补充和欠缺。它以通过预编译形式和运行期动静代理形式，实现在不批改源代码的状况下给程序动静对立增加额定性能的一种技术。 1.2 AOP遵循的准则AOP基于OCP（开闭准则）:在不扭转原有系统核心业务代码的根底上动静增加一些扩大性能并能够“管制”对象的执行。例如AOP利用于我的项目中的日志解决，事务处理，权限解决，缓存解决等等。 1.3 Spring AOP利用原理剖析Spring AOP底层基于代理机制（动静形式）实现性能扩大：1）JDK代理：如果指标对象（被代理对象）实现接口，则底层能够采纳JDK动静代理机制为指标对象创立代理对象（指标类和代理类会实现独特接口）2）CGLIB代理：如果指标对象（被代理对象）没有实现接口，则底层能够采纳CGLIB代理机制为指标对象创立代理对象（默认创立的代理类会继承指标对象类型） 1.4 Spring AOP相干术语剖析①切面(Aspect):横切面对象,个别为一个具体类对象(能够借助@Aspect申明)。②告诉(Advice):在切面的某个特定连接点上执行的动作，例如around,before,after等。③连接点(joinpoint):程序执行过程中某个特点的点，个别指向被拦挡到的指标办法。④切入点(pointcut):对多个连接点一种定义，个别能够了解为多个连接点的汇合。

关于springboot:spring-boot-下-thymeleaf-配置

thymeleaf 配置参数敞开thymeleaf缓存开发时应用否则没有实时画面spring.thymeleaf.cache=false 查看模板是否存在，而后再出现spring.thymeleaf.check-template-location=trueContent-Type值spring.thymeleaf.content-type=text/html启用MVC Thymeleaf视图分辨率spring.thymeleaf.enabled=true应该从解决方案中排除的视图名称的逗号分隔列表spring.thymeleaf.excluded-view-names=模板编码spring.thymeleaf.mode=LEGACYHTML5###### 事后查看名称的前缀 spring.thymeleaf.prefix=classpath:/templates/附加查看名称的后缀.spring.thymeleaf.suffix=.html###### 中模板解析器的程序 spring.thymeleaf.template-resolver-order=###### 名称的逗号分隔列表 spring.thymeleaf.view-names=结尾肯定要有 #thymeleaf end 否则掉坑 thymeleaf end

关于springboot:Spring-boot-多文件配置

作用开发、公布过程中，须要切换多种环境（如数据库链接，端口号等）网上搜寻了，后果搜到很多辣鸡文章，漏了要害信息配不胜利，所以写下亲测可用的过程，防止前面的老铁被耽搁最初终于找到了一篇正确的，不过内容不简练，重新整理取得，大家也能够间接看原文章：https://blog.csdn.net/xiaocho...次要步骤在pom.xml增加配置在resources增加对应环境的配置文件运行指定配置环境idea2020 spring-boot 2.3.1RELEASEJDK 14.0.2 具体步骤1.在pom.xml中增加配置增加环境 <profiles> <profile> <id>dev</id> <properties> <environment>dev</environment>  </properties> <activation> <activeByDefault>true</activeByDefault>  </activation> </profile> <profile> <id>beta</id> <properties> <environment>beta</environment>  </properties> </profile></profiles>增加资源配置 <build> <resources> <resource> <directory>src/main/resources</directory> <includes> <include>application.properties </include> <include>application-${environment}.properties</include>  <include>**/*.xml</include>  <include>**/*.sql</include>  </includes> <filtering>true</filtering>  </resource> </resources></build>此时在Maven窗口会看到配置选项增加配置文件增加application-dev.properties 增加application-beta.properties 两个文件名对应pom.xml中的 application-${environment}.properties 环境配置文件是在原配置上叠加笼罩的 ...

关于springboot:SpringBoot-DB-系列h2databse-集成示例-demo

【SpringBoot DB 系列】h2databse 集成示例 demoh2dabase 基于内存的数据库，更常见于嵌入式数据库的应用场景，依赖小，功能齐全；一般来讲，失常的商业我的项目用到它的场景不多，然而在一些非凡的 case 中，还是比拟有用的，比方用于单元测试，业务缓存，一些简略的示例 demo 等；本文将手把手教你创立一个继承 h2dabase 的我的项目，并反对从 sql 中导入预约好的 schema 和 data  I. 我的项目创立本文对应的示例 demo，采纳SpringBoot 2.2.1.RELEASE + maven 3.5.3 + IDEA进行开发 1. pom 配置对于如何创立一个 springboot 我的项目本文就不介绍了，在咱们创立好的我的项目中，pom.xml文件如下 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.1.RELEASE</version> <relativePath/> </parent><dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> </dependency></dependencies><build> <pluginManagement> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </pluginManagement></build><repositories> <repository> <id>spring-snapshots</id> <name>Spring Snapshots</name> <url>https://repo.spring.io/libs-snapshot-local</url> <snapshots> <enabled>true</enabled> </snapshots> </repository> <repository> <id>spring-milestones</id> <name>Spring Milestones</name> <url>https://repo.spring.io/libs-milestone-local</url> <snapshots> <enabled>false</enabled> </snapshots> </repository> <repository> <id>spring-releases</id> <name>Spring Releases</name> <url>https://repo.spring.io/libs-release-local</url> <snapshots> <enabled>false</enabled> </snapshots> </repository></repositories>重点关注一下dependency中的com.h2database，另外两个非必须，只是在前面的测试用例中会用到，举荐加上 ...

关于springboot:springboot-最新稳定版

1、springboot 外围依赖最新版本：Spring Boot 2.3.3Spring Cloud Hoxton.SR8Spring Cloud Alibaba 2.2.2MybatisPlus 3.4.0Element 2.3.122、更新auth认证时，更改，RedisTokenStore记录登录用户，同时保障单点、多点登录，token认证胜利之后对于雷同的用户信息返回的token值是一样的，不适宜在多地同时登录。重写DefaultAuthenticationKeyGeneratorpublic class AuthenticationKeyGenerator extends DefaultAuthenticationKeyGenerator { private static final String CLIENT_ID = "client_id";private static final String SCOPE = "scope"; private static final String USERNAME = "username"; @Override public String extractKey(OAuth2Authentication authentication) { Map<String, String> values = new LinkedHashMap<String, String>();OAuth2Request authorizationRequest = authentication.getOAuth2Request(); if (!authentication.isClientOnly()) { //在用户名前面增加工夫戳，使每次的key都不一样values.put(USERNAME, authentication.getName()+System.currentTimeMillis()); } values.put(CLIENT_ID, authorizationRequest.getClientId());if (authorizationRequest.getScope() != null) { values.put(SCOPE, OAuth2Utils.formatParameterList(new TreeSet<String>(authorizationRequest.getScope())));} ...

关于springboot:SpringBootMyBatisSpring-技术整合实现商品模块的CRUD操作

SpringBoot+MyBatis+Spring 技术整合实现商品模块的CRUD操作 javaspringspringboot 业务形容基于Spring,MyBatis,SpringBoot,Thymeleaf技术实现商品模块的增删改查操作。我的项目环境初始化筹备工作1. MySQL(5.7)2. JDK (1.8)3. Maven (3.6.3)4. STS(4.7.1)数据库初始化关上mysql控制台,而后按如下步骤执行goods.sql文件。第一步:登录mysql。 mysql –uroot –proot第二步:设置控制台编码方式。 set names utf8;第三步:执行goods.sql文件（切记不要关上文件复制到mysql客户端运行）。 source d:/goods.sql其中goods.sql文件内容如下： drop database if exists dbgoods;create database dbgoods default character set utf8;use dbgoods;create table tb_goods( id bigint primary key auto_increment, name varchar(100) not null, remark text, createdTime datetime not null)engine=InnoDB;insert into tb_goods values (null,'java','very good',now());insert into tb_goods values (null,'mysql','RDBMS',now());insert into tb_goods values (null,'Oracle','RDBMS',now());insert into tb_goods values (null,'java','very good',now());insert into tb_goods values (null,'mysql','RDBMS',now());insert into tb_goods values (null,'Oracle','RDBMS',now());insert into tb_goods values (null,'java','very good',now());创立我的项目并增加依赖第一步：基于start.spring.io 创立我的项目并设置根本信息 ...

关于springboot:Spring-Boot-集成-JWT-实现用户登录认证

JWT 简介什么是 JWTJWT 是 JSON Web Token 的缩写，是为了在网络应用环境间传递申明而执行的一种基于 JSON 的凋谢规范（(RFC 7519)。定义了一种简洁的，自蕴含的办法用于通信单方之间以 JSON 对象的模式平安的传递信息。因为数字签名的存在，这些信息是可信的，JWT 能够应用 HMAC 算法或者是 RSA 的公私秘钥对进行签名。 JWT申请流程用户应用账号和明码发动 POST 申请；服务器应用私钥创立一个 JWT；服务器返回这个 JWT 给浏览器；浏览器将该 JWT 串在申请头中像服务器发送申请；服务器验证该 JWT；返回响应的资源给浏览器。JWT 的次要利用场景身份认证在这种场景下，一旦用户实现了登录，在接下来的每个申请中蕴含 JWT，能够用来验证用户身份以及对路由，服务和资源的拜访权限进行验证。因为它的开销十分小，能够轻松的在不同域名的零碎中传递，所有目前在单点登录（SSO）中比拟宽泛的应用了该技术。信息替换在通信的单方之间应用 JWT 对数据进行编码是一种十分平安的形式，因为它的信息是通过签名的，能够确保发送者发送的信息是没有通过伪造的。 JWT 数据结构JWT 是由三段信息形成的，将这三段信息文本用 . 连贯一起就形成了 JWT 字符串。 JWT 的三个局部顺次为头部：Header，负载：Payload 和签名：Signature。 HeaderHeader 局部是一个 JSON 对象，形容 JWT 的元数据，通常是上面的样子。 { "alg": "HS256", "typ": "JWT"}下面代码中，alg 属性示意签名的算法（algorithm），默认是 HMAC SHA256（写成 HS256）；typ 属性示意这个令牌（token）的类型（type），JWT 令牌对立写为 JWT。最初，将下面的 JSON 对象应用 Base64URL 算法转成字符串。 ...

关于springboot:Spring-Boot-教程启用-HTTPS

【注】本文译自： https://www.tutorialspoint.com/spring_boot/spring_boot_enabling_https.htm Spring Boot 利用默认以 HTTP 8080 端口启动。你要在 Spring Boot 利用中执行以下步骤来配置 HTTPS 和端口 443：获取 SSL 证书：创立自签名证书或者从一个证书认证机构申请一个。启用 HTTPS 和 443 端口自签名证书 Java 运行时环境曾经内置了证书治理实用工具，可用于创立自签名证书。示例代码如下: keytool -genkey -alias tomcat -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650Enter keystore password: Re-enter new password: What is your first and last name? [Unknown]: What is the name of your organizational unit? [Unknown]: What is the name of your organization? [Unknown]: What is the name of your City or Locality? [Unknown]: What is the name of your State or Province? [Unknown]: What is the two-letter country code for this unit? [Unknown]: Is CN = Unknown, OU=Unknown, O = Unknown, L = Unknown, ST = Unknown, C = Unknown correct? [no]: yes 这段代码将产生一个名为 keystore.p12 的PKCS12 keystore 文件，证书别名为 tomcat。 ...

关于springboot:转载Spring-Boot自动配置原理

引言不管在工作中，亦或是求职面试，Spring Boot曾经成为咱们必知必会的技能项。除了某些老旧的政府我的项目或金融我的项目持有张望态度外，现在的各行各业都在飞速的拥抱这个曾经不是很新的Spring启动框架。当然，作为Spring Boot的精华，主动配置原理的工作过程往往只有在“面试”的时候能力用得上，然而如果在工作中你可能深刻的了解Spring Boot的主动配置原理，将无往不利。 Spring Boot的呈现，得益于“习惯优于配置”的理念，没有繁琐的配置、难以集成的内容（大多数风行第三方技术都被集成），这是基于Spring 4.x提供的按条件配置Bean的能力。 Spring Boot的配置文件初识Spring Boot时咱们就晓得，Spring Boot有一个全局配置文件：application.properties或application.yml。咱们的各种属性都能够在这个文件中进行配置，最常配置的比方：server.port、logging.level.* 等等，然而咱们理论用到的往往只是很少的一部分，那么这些属性是否有据可依呢？答案当然是必定的，这些属性都能够在官网文档中查找到： https://docs.spring.io/spring-boot/docs/2.1.0.RELEASE/reference/htmlsingle/#common-application-properties （所以，话又说回来，找材料还得是官网文档，百度进去一大堆，还是稍显业余了一些）除了官网文档为咱们提供了大量的属性解释，咱们也能够应用IDE的相干提醒性能，比方IDEA的主动提醒，和Eclipse的YEdit插件，都能够很好的对你须要配置的属性进行提醒，下图是应用Eclipse的YEdit插件的成果，Eclipse的版本是：STS 4。以上，是Spring Boot的配置文件的大抵应用办法，其实都是些题外话。那么问题来了：这些配置是如何在Spring Boot我的项目中失效的呢？那么接下来，就须要聚焦本篇博客的主题：主动配置工作原理或者叫实现形式。工作原理分析Spring Boot对于主动配置的源码在spring-boot-autoconfigure-x.x.x.x.jar中：当然，主动配置原理的相干形容，官网文档貌似是没有提及。不过咱们不难猜出，Spring Boot的启动类上有一个@SpringBootApplication注解，这个注解是Spring Boot我的项目必不可少的注解。那么主动配置原理肯定和这个注解有着千头万绪的分割！ @EnableAutoConfiguration @SpringBootApplication是一个复合注解或派生注解，在@SpringBootApplication中有一个注解@EnableAutoConfiguration，翻译成人话就是开启主动配置，其定义如下：而这个注解也是一个派生注解，其中的要害性能由@Import提供，其导入的AutoConfigurationImportSelector的selectImports()办法通过SpringFactoriesLoader.loadFactoryNames()扫描所有具备META-INF/spring.factories的jar包。spring-boot-autoconfigure-x.x.x.x.jar里就有一个这样的spring.factories文件。这个spring.factories文件也是一组一组的key=value的模式，其中一个key是EnableAutoConfiguration类的全类名，而它的value是一个xxxxAutoConfiguration的类名的列表，这些类名以逗号分隔，如下图所示：这个@EnableAutoConfiguration注解通过@SpringBootApplication被间接的标记在了Spring Boot的启动类上。在SpringApplication.run(...)的外部就会执行selectImports()办法，找到所有JavaConfig主动配置类的全限定名对应的class，而后将所有主动配置类加载到Spring容器中。主动配置失效每一个XxxxAutoConfiguration主动配置类都是在某些条件之下才会失效的，这些条件的限度在Spring Boot中以注解的模式体现，常见的条件注解有如下几项： @ConditionalOnBean：当容器里有指定的bean的条件下。@ConditionalOnMissingBean：当容器里不存在指定bean的条件下。 @ConditionalOnClass：当类门路下有指定类的条件下。 @ConditionalOnMissingClass：当类门路下不存在指定类的条件下。 @ConditionalOnProperty：指定的属性是否有指定的值，比方@ConditionalOnProperties(prefix=”xxx.xxx”, value=”enable”, matchIfMissing=true)，代表当xxx.xxx为enable时条件的布尔值为true，如果没有设置的状况下也为true。以ServletWebServerFactoryAutoConfiguration配置类为例，解释一下全局配置文件中的属性如何失效，比方：server.port=8081，是如何失效的（当然不配置也会有默认值，这个默认值来自于org.apache.catalina.startup.Tomcat）。在ServletWebServerFactoryAutoConfiguration类上，有一个@EnableConfigurationProperties注解：开启配置属性，而它前面的参数是一个ServerProperties类，这就是习惯优于配置的最终落地点。在这个类上，咱们看到了一个十分相熟的注解：@ConfigurationProperties，它的作用就是从配置文件中绑定属性到对应的bean上，而@EnableConfigurationProperties负责导入这个曾经绑定了属性的bean到spring容器中（见下面截图）。那么所有其余的和这个类相干的属性都能够在全局配置文件中定义，也就是说，真正“限度”咱们能够在全局配置文件中配置哪些属性的类就是这些XxxxProperties类，它与配置文件中定义的prefix关键字结尾的一组属性是惟一对应的。至此，咱们大抵能够理解。在全局配置的属性如：server.port等，通过@ConfigurationProperties注解，绑定到对应的XxxxProperties配置实体类上封装为一个bean，而后再通过@EnableConfigurationProperties注解导入到Spring容器中。而诸多的XxxxAutoConfiguration主动配置类，就是Spring容器的JavaConfig模式，作用就是为Spring 容器导入bean，而所有导入的bean所须要的属性都通过xxxxProperties的bean来取得。可能到目前为止还是有所纳闷，但面试的时候，其实远远不须要答复的这么具体，你只须要这样答复： Spring Boot启动的时候会通过@EnableAutoConfiguration注解找到META-INF/spring.factories配置文件中的所有主动配置类，并对其进行加载，而这些主动配置类都是以AutoConfiguration结尾来命名的，它实际上就是一个JavaConfig模式的Spring容器配置类，它能通过以Properties结尾命名的类中获得在全局配置文件中配置的属性如：server.port，而XxxxProperties类是通过@ConfigurationProperties注解与全局配置文件中对应的属性进行绑定的。通过一张图标来了解一下这一简约的流程：图片来自于王福强老师的博客：https://afoo.me/posts/2015-07-09-how-spring-boot-works.html 总结综上是对主动配置原理的解说。当然，在浏览源码的时候肯定要记得不要太过拘泥与代码的实现，而是应该抓住重点脉络。肯定要记得XxxxProperties类的含意是：封装配置文件中相干属性；XxxxAutoConfiguration类的含意是：主动配置类，目标是给容器中增加组件。而其余的主办法启动，则是为了加载这些形形色色的XxxxAutoConfiguration类。

关于springboot:SpringBoot中关于图片的上传入门

1.前端筹备 <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Insert title here</title> </head> <body> <h1>实现文件长传</h1>  <form action="http://localhost:8091/filetest" method="post" enctype="multipart/form-data"> <input name="fileImage" type="file" /> <input type="submit" value="提交"/> </form> </body> </html>2.实现文件上传的步骤阐明 package com.jt.controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.multipart.MultipartFile; import java.io.File; import java.io.IOException; @RestController public class FileTestController { @RequestMapping("/filetest") public String file(MultipartFile fileImage){ String fileDir = "F:/CloudMusic/images"; File file = new File(fileDir); if(!file.exists()){ file.mkdirs(); } String fileName = fileImage.getOriginalFilename(); File imageFile = new File(fileDir+"/"+fileName); try { fileImage.transferTo(imageFile);//Transfer the received file to the given destination file. }catch(IOException e){ e.printStackTrace(); } return "ok"; } }3.代码解释3.1 前提MultipartFile是spring类型，代表HTML中form data形式上传的文件，蕴含二进制数据+文件名称。 ...

关于springboot:SpringBoot集成springmvcmybatisthymeleaflombok常见问题一

问题1：template找不到或门路不正确template might not exist or might not be accessible by any of the configured Template Resolvers图1-1解答：1.查看该门路下是否存在对应办法，即门路是否正确2.若第一步查看无误，再查看是否你想返回的是汇合/对象类型的数据，如果是，须要增加@ResponseBody注解，否则spring MVC容器会主动解析回视图(view)格局返回，如图1-2所示：图1-2问题2：lombok增加@Data注解没有主动生成get和set办法解答：pom.xml增加了lombok依赖后，idea还须要下载一个lombok插件才能够生成get和set办法，如图1-3所示：图1-3问题3：数据绑定异样，如图1-4所示：图1-4解答：这是mybatis在帮你注入对象时找不到类所对应的操作数据库的注解或者对应xml文件导致，查看mapper的命名空间是否与你所写的类齐全对应，包含包名，以及返回类型，如图1-5所示：图1-5

关于springboot:Spring-Cloud-Gray-微服务灰度路由控制

在Spring Cloud Gray 由spring-cloud-gray-client（角色灰度客户端），spring-cloud-gray-client-netflix 和 spring-cloud-tray-server，spring-cloud-gray-webui组成。 spring-cloud-gray-client定义了一套灰度路由决策模型，灰度信息追踪模型，以及和spring-cloud-gray-server的根本通信性能。 spring-cloud-gray-client-netflix在spring-cloud-gray-client的根底上集成了微服务注册核心eureka，扩大ribbon的负载平衡规定，提供了对zuul,feign,RestTemplate的灰度路由能力，并且无缝反对hystrix线程池隔离。 spring-cloud-gray-server负责灰度决策、灰度追踪等信息的治理以及长久化。注册核心负责服务的注册和发现。灰度客户端灰度的客户端是指依赖了spring-cloud-gray-client的服务，个别是指服务生产方。灰度管控端负责灰度信息的治理、长久化等保护工作。灰度客户端会从灰度管控端拉取一份灰度信息的清单，并在内存中保护这份清单信息，清单中蕴含服务，服务实例，灰度策略，灰度追踪字段等。当申请达到网关时，网关就会在灰度追踪中将须要透传的信息记录下来，并将传递给转发的服务实例，前面的接口调用也会依照同样的逻辑将追踪信息透传下去，从而保障所有一个申请在微服务调用链中的灰度路由。 public class CustomMetadataRule extends ZoneAvoidanceRule { // 检测灰度开关是否启动private HttpResult checkGraySwitch() { String url = "http://127.0.0.1:6015/eureka/apps/switch"; HttpResult result = new HttpResult(); result.statusCode = 500; try { result = HttpClient.get(url, null); } catch (Exception e1) { e1.printStackTrace(); } return result;}@Overridepublic Server choose(Object key) { // 获取是否存在存活的服务可调用 List<Server> serverList = this.getPredicate().getEligibleServers(this.getLoadBalancer().getAllServers()); // 获取不到服务 if (CollectionUtils.isEmpty(serverList)) { return null; } // 获取灰度开关是否启动 HttpResult result = checkGraySwitch(); // 灰度开关被设置成敞开状态,默认走空metadata或者是特定标识是失常的服务,轮询拜访 Boolean isOpen = Boolean.parseBoolean(JSONObject.parseObject(result.content).getString("errorMsg")); if (result.statusCode == 200 && !isOpen) { isOpen = true; return RoundRobinRuleBySelf.getInstance().choose(this.getLoadBalancer(), key,isOpen); } // 灰度公布启动状态,未被设置成灰度对象,默认走空metadata或者是特定标识是失常的服务,轮询拜访 if (StringUtils.isEmpty(CoreHeaderInterceptor.label.get())) { isOpen = false; return RoundRobinRuleBySelf.getInstance().choose(this.getLoadBalancer(), key,isOpen); } // 灰度公布启动状态,被设置成灰度对象,走空特定标识的服务,轮询拜访 return RoundRobinRuleBySelf.getInstance().choose(this.getLoadBalancer(), key,!isOpen);}} ...

关于springboot:Spring-Boot-教程调度

【注】本文译自： https://www.tutorialspoint.co... 调度用来解决特定工夫周期的工作。Spring Boot 为 Spring 利用编写调度器提供了良好的反对。 Java Cron 表达式 Java Cron 表达式用于配置 CronTrigger 实例，是 org.quartz.Trigger 的子类。对于 Java cron 表达式的更多信息可参考：https://docs.oracle.com/cd/E1... @EnableScheduling 注解用于使你的利用可能应用调度器。这个注解该当被加在主 Spring Boot 利用类文件中。 @SpringBootApplication@EnableSchedulingpublic class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); }} @Scheduled 注解用于触发一个特定工夫周期的调度器。 @Scheduled(cron = "0 * 9 * * ?")public void cronJobSch() throws Exception {} 以下代码展现了如何在每天的早上 9:00 到 9:59 之间每分钟执行工作： package com.tutorialspoint.demo.scheduler;import java.text.SimpleDateFormat;import java.util.Date;import org.springframework.scheduling.annotation.Scheduled;import org.springframework.stereotype.Component;@Componentpublic class Scheduler { @Scheduled(cron = "0 * 9 * * ?") public void cronJobSch() { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); Date now = new Date(); String strDate = sdf.format(now); System.out.println("Java cron job expression:: " + strDate); }} 以下截图展现了利用在 09:03:23 启动之后如何每隔一分钟执行一次： ...

关于springboot:缓存服务器Redis-03-SpringBoot整合redis

整合Redis引入jar包<dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId></dependency><dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId></dependency>入门API测试案例//@SpringBootTest 如果须要在测试类中引入spring容器机制才应用此注解 public class TestRedis { /** * 测试近程redis服务器是否可用 * host: 192.168.126.129 * port: 6379 *思路: 1.实例化对象 * 2.利用对象执行redis命令 * 报错调试:1.查看redis.conf的配置文件是否依照要求批改 ip/爱护/后盾 * 2.redis启动形式 redis-server redis.conf * 3.敞开防火墙 systemctl stop firewalld.service */ @Test public void test01(){ Jedis jedis=new Jedis("192.168.126.129", 6379); jedis.set("redis", "测试redis是否可用"); System.out.println(jedis.get("redis")); } /** * String类型API练习 * 需要: 判断key是否存在于redis,如果存在则赋值,否则入库 */ @Test public void test02(){ Jedis jedis=new Jedis("192.168.126.129", 6379); if(jedis.exists("redis")){ System.out.println("数据已存在"); jedis.expire("redis", 10); }else{ jedis.set("redis","aaaa"); } System.out.println(jedis.get("redis")); } /** * 能够利用优化的API实现业务性能 * 业务: 如果数据存在则不赋值 */ @Test public void test03(){ Jedis jedis=new Jedis("192.168.126.129", 6379); jedis.flushAll();//清空redis服务器 //jedis.set("redis","111"); //如果key存在则不做任何操作 jedis.setnx("redis", "测试赋值操作!"); System.out.println(jedis.get("redis")); } /** * 测试增加超时工夫的有效性 * 业务: 向redis中保留一个数据之后,要求设定10s无效 * 原子性: 要么同时胜利,要么同时失败 */ @Test public void test04(){ Jedis jedis=new Jedis("192.168.126.129", 6379); /*jedis.set("aa","aa");//数据不删除 int a=1/0; jedis.expire("aa", 10);*/ jedis.setex("aa", 10, "aa");//单位秒 //jedis.psetex()单位毫秒 } /** * 需要: 增加一个数据,只有数据存在时才会赋值,并且须要增加超时工夫 * 保障原子性操作 * private static final String XX = "xx";有key才赋值 * private static final String NX = "nx";没有key才赋值 * private static final String PX = "px";毫秒 * private static final String EX = "ex";秒 * * redis分布式锁问题 */ @Test public void test05(){ Jedis jedis=new Jedis("192.168.126.129", 6379); SetParams setParams=new SetParams(); setParams.xx().ex(10); jedis.set("aaa", "aaa",setParams); } @Test public void testhash(){ Jedis jedis=new Jedis("192.168.126.129", 6379); jedis.hset("user", "id", "100"); jedis.hset("user", "name", "tomcat"); System.out.println(jedis.hget("user", "id")); System.out.println(jedis.hget("user", "name")); if(jedis.hexists("user", "id")&&jedis.hexists("user", "name")){ System.out.println("存在"); }else { System.out.println("不存在"); } System.out.println(jedis.hgetAll("user")); System.out.println(jedis.hkeys("user")); jedis.hdel("user", "id","name"); System.out.println(jedis.hgetAll("user")); } @Test public void testlist(){ Jedis jedis=new Jedis("192.168.126.129", 6379); jedis.lpush("list2", "1,2,3,4,5"); System.out.println(jedis.rpop("list2")); } /** * 管制redis事务 * 阐明:操作单台redis实用于事务管理,然而如果多台redis则不太实用事务 */ @Test public void testTx() { Jedis jedis = new Jedis("192.168.126.129", 6379); //开启事务 Transaction transaction = jedis.multi(); try { transaction.set("bb", "bb"); transaction.exec();//提交事务 }catch (Exception e){ transaction.discard();//回滚事务 } } }SpringBoot整合Redis配置类地位因为redis之后会被其余的服务器实用,所以最好的形式将Redis的配置类保留到common包下 ...

关于springboot:SpringBoot2-集成日志复杂业务下的自定义实现

本文源码：GitHub·点这里 || GitEE·点这里一、日志体系集成1、日志治理在零碎的开发中，最要害的一个组件工具就是日志，日志打印不便问题排查，或者生产事变回溯，日志记录用来监控并剖析零碎性能点，并以此为根据，一直对系统进行优化；同时基于用户的操作日志，对用户行为进行剖析，开发智能举荐的性能，或者进行营销投放，这在零碎中都是常见且要害的业务流程。 2、ELK日志体系在大型零碎架构中，ELK的日志管理系统是零碎必备性能，ELK-Stack是Elasticsearch、Logstash、Kiban三个开源软件的组合，通常用来做日志剖析，实时数据检索。基于Logstash做数据流动通道，使日志数据一直的流入搜寻组件，基于Elasticsearch做数据实时查问，基于Kiban的ES可视化界面，以此实现日志数据的收集、存储、剖析等外围性能，且该体系不便扩大。 ELK相干文章： SpringBoot2整合ElasticSearch框架搜索引擎框架，ElasticSearch集群模式基于Logstash全量或增量同步数据到ES中间件基于ELK体系的外围操作，有对于ElasticSearch其余文章能够自行查阅之前的内容，这里不在排列，如同很多货色都是这样一点点积攒进去的。二、集成环境1、我的项目构造 defined-log-api：测试工程； defined-log-config：日志外围模块，依赖之后应用该模块下注解即可； 2、数据表构造CREATE TABLE dt_defined_log ( id INT ( 11 ) NOT NULL AUTO_INCREMENT COMMENT '主键', class_name VARCHAR ( 200 ) DEFAULT NULL COMMENT '申请类名', method_name VARCHAR ( 100 ) DEFAULT NULL COMMENT '申请办法名', method_desc VARCHAR ( 100 ) DEFAULT NULL COMMENT '申请办法形容', api_type INT ( 1 ) DEFAULT 0 COMMENT 'API类型', biz_nature INT ( 1 ) DEFAULT 0 COMMENT '业务性质类型', data_flow_type INT ( 1 ) DEFAULT 0 COMMENT '日志数据流向', req_param VARCHAR ( 200 ) DEFAULT NULL COMMENT '申请报文', res_param VARCHAR ( 200 ) DEFAULT NULL COMMENT '响应报文', PRIMARY KEY ( `id` ) ) ENGINE = INNODB DEFAULT CHARSET = utf8 COMMENT = '日志记录表';这里齐全基于业务需要自定义即可。 ...

关于springboot:Spring-Boot-应用加强实现健康检查热部署Lombok插件应用

一、健康检查配置及测试1、间接在我的项目中增加依赖 2、健康检查剖析：在浏览器中输出如下地址：http://localhost/actuator/health 如果心愿查看更多actuator选项，能够在spring boot中配置文件application.properties中增加如下语句:（生产环境不加） management.endpoints.web.exposure.include=*此时在浏览器地址栏能够输出.http://localhost/actuator/beans 查看所有的spring 容器中的bean信息。阐明:当须要以一种更好的结构化形式查看bean相干信息,能够对Google浏览器装置jsonView插件,还能够间接在sts工具的Boot Dashboard中选中我的项目,查看其属性(show properties)，这种形式重点把握。二、热部署配置及实现基于SpringBoot的Web我的项目,批改了某个类当前,默认不会主动重新部署和加载,须要咱们手动重启服务器。如果咱们心愿我的项目能够主动部署,能够增加如下依赖,进行热部署实现。阐明:当咱们批改了src/main/java目录下的java文件或批改了src/main/resources目录下的配置文件时，默认都会重启你的web服务器，然而批改了测试类或html文件不会主动重启和部署。三、Lombok插件利用Lombok是一个第三库，能够基于lombok中提供的API，在程序编译时主动织入一些办法。这样做的话能够简化咱们对某些办法的编写，例如，省略pojo类中的set办法，get办法，toString等办法的编写。咱们写的java程序能够在编译时，通过lombok主动将这些办法增加到.class文件中，其利用步骤如下：第一步：增加依赖。第二步:找到下载的lombok-xxx.jar依赖所在的地位。第三步:启动操作系统命令行客户端，并切换到lombok-xxx.jar文件所在的目录，而后，利用java –jar 指令启动lombok插件，如图所示：回车执行如上命令，会弹出抉择装置对话框，如图所示：而后在弹出的框中抉择sts启动执行文件(SpringToolSuite4.exe)进行装置,装置胜利当前会呈现如下弹出框，如图所示：装置胜利当前可在STS工具的根目录看到一个lombok.jar文件,同时会在SpringToolSuite4.ini文件的尾部增加lombok.jar文件所在的具体门路，例如-javaagent:E:softwarests-4.5.3.RELEASElombok.jar。其中lombok.jar会默认创立在sts软件的根目录，如图所示：阐明:装置胜利当前重启sts工具.(如果装置胜利当前再次启动sts,此时无奈启动,可能与STS所在目录有关系,能够将装置目录下的lombok.jar文件拷出到特定目录,而后批改SpringToolSuite4.ini文件的最初一行的lombok.jar门路即可，同时在配置文件中也不能有空格)。 Lombok 罕用注解剖析：▪ @Setter 用于为形容的类生成setter办法,不蕴含final润饰属性。▪ @Getter 用于为形容的类生成getter办法。 ▪ @ToString 用于为形容的类增加toString办法。▪ @EqualsAndHashCode 用于为形容的类，生成hashCode和equals办法。▪ @NoArgsConstructor 用于为形容的类生成无参的构造方法。▪ @AllArgsConstructor 用于为形容的类生成蕴含类中所有字段的构造方法。▪ @Data用于为形容的类生成setter/getter、equals、canEqual、hashCode、toString办法，如为final属性，则不会为该属性生成setter办法。▪ @Slf4J 用于为形容的类增加一个日志属性对象private static final Logger log=LoggerFactory.getLogger(Xxx.class);

关于springboot:Spring-Boot-教程国际化

【注】本文译自： https://www.tutorialspoint.com/spring_boot/spring_boot_internationalization.htm 国际化是一种解决机制，使得你的利用能够适配不同的语言和区域而无需更改源代码。换言之，国际化是为本地化而筹备。本文将带你学习在 Spring Boot 中如何实现国际化的细节。依赖在 Spring Boot 中开发 web 利用，咱们须要依赖 Spring Boot Starter Web 和 Spring Boot Starter Thymeleaf 依赖项。 Maven<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId></dependency><dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId></dependency>Gradlecompile('org.springframework.boot:spring-boot-starter-web')compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'LocaleResolver 要确定你的利用的缺省本地化，须要在 Spring Boot 利用中减少 LocaleResolver bean。 @Beanpublic LocaleResolver localeResolver() { SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver(); sessionLocaleResolver.setDefaultLocale(Locale.US); return sessionLocaleResolver;}LocaleChangeInterceptor LocaleChangeInterceptor 用于依据申请所带的语言参数来切换新的本地化。 @Beanpublic LocaleChangeInterceptor localeChangeInterceptor() { LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor(); localeChangeInterceptor.setParamName("language"); return localeChangeInterceptor;} 要把 LocaleChangeInterceptor 加到利用注册拦截器中能力失效。这个配置类该当继承 WebMvcConfigurerAdapter 类且重载 addInterceptors() 办法。 ...

关于springboot:Spring-Boot-教程CORS-支持

【注】本文译自： https://www.tutorialspoint.co... 跨域资源共享 (CORS) 是一个平安概念，它容许在 web 浏览器中实现对资源拜访的限度。它可防止 JavaScript 代码产生或生产别逾越不同域的申请。例如，你的运行在 8080 端口的 web 利用试图应用 JavaScript 生产来自 9090 端口的 RESTful web 服务。在这样的情景下，你将面对 web 浏览器上跨域资源共享的平安问题。这个问题有两个需要要解决： RESTful web 服务该当反对跨域资源共享。RESTful web 服务利用该当容许来自 8080 端口拜访 API(s)。在本文中，咱们将具体学习如何让一个 RESTful Web 服务利用可能进行跨域申请。在控制器办法中使能 CORS 咱们须要在控制器办法上对一个 RESTful web 服务应用 @CrossOrigin 设置源。@CrossOrigin 注解反对指定 REST API，而不是对整个利用。 @RequestMapping(value = "/products")@CrossOrigin(origins = "http://localhost:8080")public ResponseEntity<Object> getProduct() { return null;}全局 CORS 配置要定义 @Bean 以对 Spring Boot 利用全局配置 CORS。 ...

关于springboot:springbootajax查看直接可以返回查询页面

@Controller@RequestMapping("/activity/")public class ActivityController { @Autowiredprivate ActivityService activityService;@RequestMapping("doSaveObject")public String doSaveObject(Activity enrity) { activityService.insertObject(enrity); return "activity";}@RequestMapping("doActivityUI")public String doActivityUI(){ return "activity";}/**查问所有流动信息*/@RequestMapping("doFindActivitys")@ResponseBody//以字符串返回值;public List<Activity> doFindActivitys() { List<Activity> list=activityService.findActivitys(); return list;}} 前端<!DOCTYPE html><html><head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1"><link href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css"rel="stylesheet"><title>Insert title here</title></head><body> <div class="container"> <h1>The Activity Page</h1>  <button type="button" class="btn btn-success" data-toggle="modal" data-target="#myModal">创立新流动</button>  <div class="modal fade" id="myModal" tabindex="-1" role="dialog" aria-labelledby="myModalLabel"> <div class="modal-dialog" role="document"> <div class="modal-content"> <div class="modal-header"> <button type="button" class="close" data-dismiss="modal" aria-label="Close"> <span aria-hidden="true">×</span> </button> <h4 class="modal-title" id="myModalLabel">增加流动</h4> </div> <div class="modal-body"> <form action="/activity/doSaveObject" method="post"> <div class="form-group"> <label for="titleId">title</label> <input type="text" class="form-control" name="title" id="titleId" placeholder="please input title"> </div> <div class="form-group"> <label for="cagegoryId">Category</label> <select class="form-control" name="category" id="category"> <option value="training">教育培训</option> <option value="Playing">企业流动</option> </select> </div> <div class="form-group"> <label for="startTimeId">start time</label> <input type="text" class="form-control" name="startTime" id="startTimeId" placeholder="please input startTime"> </div> <div class="form-group"> <label for="endTimeId">end time</label> <input type="text" class="form-control" name="endTime" id="endTimeId" placeholder="please input end time"> </div> <div class="form-group"> <label for="remarkId">Remark</label> <textarea class="form-control" name="remark" id="remarkId"></textarea> </div> </form> </div> <div class="modal-footer"> <button type="button" class="btn btn-default" data-dismiss="modal">Close</button> <button type="button" class="btn btn-primary" onclick="doSaveObject()">Save changes</button> </div> </div> </div> </div> <table class="table"> <thead> <tr> <th>id</th> <th>title</th> <th>category</th> <th>start time</th> <th>end time</th> <th>state</th> <th>createdTime</th> </tr> </thead> <tbody id="tbodyId"> <tr> <td colspan="7">数据正在踊跃的加载中......</td> </tr> </tbody> </table></div><script type="text/javascript" src="/jquery/jquery.min.js"></script><script src="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/js/bootstrap.min.js"></script><script type="text/javascript">//点击事件function doSaveObject(){ $("form").submit();//提交表单 submit}//向服务端发送异步申请获取流动信息并更新到页面上function findActivitys(){ let url="/activity/doFindActivitys"; let params={}; //借助jquery中的ajax函数,向服务端发送异步申请获取流动信息 $.ajax({ url:url, data:params, dataType:"json", success:function(result){ doHandleQueryResult(result); } });};//解决服务端返回的流动信息,迭代result,并将result内容填充tbody地位function doHandleQueryResult(result){ ///debugger console.log(result) //1.获取tbody对象,并清空原有内容 var tBody=$("#tbodyId");//原生写法-document.querySelector("#tbodyId") tBody.empty();//清空tbody中原有内容 //2.迭代result,将流动信息追加到tbody中 result.forEach((item)=>{//这里的item为一个变量,代表数组中某一个元素 //debugger tBody.append( `<tr> <td>${item.id}</td> <td>${item.title}</td> <td>${item.category}</td> <td>${item.startTime}</td> <td>${item.endTime}</td> <td>${item.state==1?'无效':'已完结'}</td> <td>${item.createdTime}</td> </tr>` ); });}//jquery中定义的页面加载残缺执行形式如下: // $(function(){//如果所有的js代码放到html页面的head标签,倡议这样写 ...

关于springboot:Spring-Boot-教程服务组件

【注】本文译自： https://www.tutorialspoint.co... 服务组件是蕴含 @Service 注解的类文件。这些类文件可用在与 @RestController 类文件所不同的层来编写业务逻辑。创立服务组件类文件如下所示： public interface ProductService {} 以 @Service 注解实现接口的类如下所示： @Servicepublic class ProductServiceImpl implements ProductService {} 回顾以前的教程中，咱们应用产品服务 API(s) 来存储、获取、更新和删除产品。咱们在 @RestController 类文件本身中编写业务逻辑。当初咱们要把业务逻辑代码从控制器移到服务组件。你能够创立一个接口，蕴含减少、编辑、获取和删除办法，示例代码如下： package com.tutorialspoint.demo.service;import java.util.Collection;import com.tutorialspoint.demo.model.Product;public interface ProductService { public abstract void createProduct(Product product); public abstract void updateProduct(String id, Product product); public abstract void deleteProduct(String id); public abstract Collection<Product> getProducts();} 以下代码将让你创立一个以 @Service 注解来实现 ProductService 接口的类，用以编写存储、获取、删除和更新产品。 package com.tutorialspoint.demo.service;import java.util.Collection;import java.util.HashMap;import java.util.Map;import org.springframework.stereotype.Service;import com.tutorialspoint.demo.model.Product;@Servicepublic class ProductServiceImpl implements ProductService { private static Map<String, Product> productRepo = new HashMap<>(); static { Product honey = new Product(); honey.setId("1"); honey.setName("Honey"); productRepo.put(honey.getId(), honey); Product almond = new Product(); almond.setId("2"); almond.setName("Almond"); productRepo.put(almond.getId(), almond); } @Override public void createProduct(Product product) { productRepo.put(product.getId(), product); } @Override public void updateProduct(String id, Product product) { productRepo.remove(id); product.setId(id); productRepo.put(id, product); } @Override public void deleteProduct(String id) { productRepo.remove(id); } @Override public Collection<Product> getProducts() { return productRepo.values(); }} 以里的代码展现了 Rest Controller 类文件，咱们用 @Autowired 来主动注入 ProductService 接口并调用其办法。 ...

关于springboot:springboot跨域问题-HTTP访问控制CORS

1.谬误形容其实就还是我上个guacamole我的项目的衍生问题，因为要提供一个供外界拜访的接口，以后端页面填入我在其余服务器上安排的guacamole server的地址的时候（我用的firefox浏览器）在控制台能够分明地看到 CORS 头短少 'Access-Control-Allow-Origin'这些字样 2.解决这里先上解决办法，试了好多种只有这个能够 import org.springframework.context.annotation.Configuration;import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;import org.springframework.context.annotation.Bean;import org.springframework.web.cors.CorsConfiguration;import org.springframework.web.cors.UrlBasedCorsConfigurationSource;import org.springframework.web.filter.CorsFilter;@Configurationpublic class GlobalCorsConfig extends WebMvcConfigurerAdapter { private CorsConfiguration buildConfig() { CorsConfiguration corsConfiguration = new CorsConfiguration(); corsConfiguration.addAllowedOrigin("*"); corsConfiguration.addAllowedHeader("*"); corsConfiguration.addAllowedMethod("*"); corsConfiguration.addExposedHeader("Content-Type"); corsConfiguration.addExposedHeader( "X-Requested-With"); corsConfiguration.addExposedHeader("accept"); corsConfiguration.addExposedHeader("Origin"); corsConfiguration.addExposedHeader( "Access-Control-Request-Method"); corsConfiguration.addExposedHeader("Access-Control-Request-Headers"); corsConfiguration.setAllowCredentials(true); return corsConfiguration; } @Bean public CorsFilter corsFilter() { UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(); source.registerCorsConfiguration("/**", buildConfig()); return new CorsFilter(source); }}创立这个类，而后在须要进行跨域的类下面加上注解@CrossOrigin跨域问题就解决了！具体原理我还没了解，了解了补上，这里贴一下帮我解决问题的网址：https://www.w3xue.com/exp/article/20193/23459.html

关于springboot:SpringBoot初学

1.SpringBoot是什么？Spring boot是一个脚手架，构建于Spring框架(Framework)根底之上，基于疾速构建理念，提供了主动配置性能，可实现其开箱即用个性（创立完一个根本的我的项目当前，可零配置或者大量配置即可运行咱们的我的项目）2.SpringBoot外围劣势是什么？起步依赖(Starter Dependency)-我的项目创立时底层帮你关联依赖。主动配置(Auto Configuration)。健康检查(Actator)-监控3.SpringBot我的项目启动时，Bean的初始化过程是怎么的？SpringBoot我的项目在启动时，首先基于启动入口类的注解形容，进行主动配置并扫描指定包以及自包中的类进行加载，而后检测类上是否有Spring框架中指定的注解形容(例如@Component，@Controller，@Service等),即查找，加载，读和存储配置，创立和存储实例对象。如果有，则将类交给Spring框架中的BeanFactory工厂接口的实现类对象，此工厂对象会基于反射创立Bean的实例如果指定了生命周期办法，还会调用生命周期办法，当实例创立当前，Spring框架还会基于类的作用域形容，将实例对象存储到不必作用域的容器中，以实现Bean对象的迷信利用。如图所示： XxxApplication示意启动类 Xxx.class示意磁盘中的字节码文件 BeanFactory为创立Bean的工厂 ApplicationContext为治理Bean对象的作用域的上下文对象 Map<String.Object>为存储个种作用域的容器 4.SpringBoot 我的项目启动时，Bean对象的依赖注入过程是怎么的？(标记，查找，注入)如图：在上图中形容了DefaultCacheTests类与DefaultCache类的关系，这两个类通过指定注解（@SpringBootTest,@Component）进行了形容，其用意是通知spring框架这个两个类的实例的创立由Spring负责，并且由Spring框架基于@Autowired注解的形容实现DefaultCacheTests实例中无关DefaultCache类型的值的注入(DI)。 5.Spring 框架中的Bean对象有什么个性？(提早加载，作用域，生命周期办法)Spring框架能够为由它治理的对象（Bean）提供懒加载策略（对象临时用不到，则无需加载和实例化），Scope作用域（例如singleton-(单例)频繁用时能够思考内存中只有一份, prototype-(多例)应用次数少时能够用时创立，不必时销毁），Lifecycle method生命周期办法（更好实现对象的初始化和资源销毁），以实现对象对系统资源的无效应用。实现bean对象的无效治理。同时Spring框架还能够基于用户设计治理对象与对象的依赖关系，以升高对象与对象之间的间接耦合，进步程序的可维护性和可扩展性。 6.Spring 框架中单例(singleton)作用域对象特点，利用场景(频繁用)？特点：保障一个类仅有一个实例，并提供一个拜访它的全局拜访点。并且因为实例是在 Instance 属性办法外部创立的，因而类能够应用附加性能（例如，对子类进行实例化），即便它可能引入不想要的依赖性。而且直到对象要求产生一个实例才执行实例化；这种办法称为“惰性实例化”。惰性实例化防止了在应用程序启动时实例化不必要的 singleton。利用场景：须要回收重要资源(数据库连贯等)的事宜配置为singleton，如果配置为prototype须要利用确保资源失常回收。 Windows的Task Manager（工作管理器）就是很典型的单例模式windows的Recycle Bin（回收站）也是典型的单例利用。在整个零碎运行过程中，回收站始终保护着仅有的一个实例。网站的计数器，个别也是采纳单例模式实现，否则难以同步。应用程序的日志利用，个别都何用单例模式实现，这个别是因为共享的日志文件始终处于关上状态，因为只能有一个实例去操作，否则内容不好追加。Web利用的配置对象的读取，个别也利用单例模式，这个是因为配置文件是共享的资源。数据库连接池的设计个别也是采纳单例模式，因为数据库连贯是一种数据库资源。数据库软件系统中应用数据库连接池，次要是节俭关上或者敞开数据库连贯所引起的效率损耗，这种效率上的损耗还是十分低廉的，因为何用单例模式来保护，就能够大大降低这种损耗。多线程的线程池的设计个别也是采纳单例模式，这是因为线程池要不便对池中的线程进行管制。操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。9. HttpApplication 也是单位例的典型利用。相熟ASP.Net(IIS)的整个申请生命周期的人应该晓得HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例. 总结以上，不难看出：单例模式利用的场景个别发现在以下条件下：（1）资源共享的状况下，防止因为资源操作时导致的性能或损耗等。如上述中的日志文件，利用配置。（2）管制资源的状况下，不便资源之间的相互通信。如线程池等。 7.Spring 框架中多例(prototype)作用域对象特点，利用场景(稀少用)？特点：prototype拜访一次创立一个实例，相当于new。与singleton区别：singleton的生命周期由容器来治理，然而prototype的生命周期得你本人治理利用场景：有状态的Bean（比方说MVC中的action）配置成singleton会引发未知问题，能够思考配置为prototype。 FAQ？Maven工具(我的项目构建工具)从哪里下载?(maven.apache.org)STS(集成了spring插件的eclipse)工具从哪里下载?(spring.io/tools)STS新版本怎么装置?(例如STS4.5.0的装置可应用:java -jar xxx.jar)创立spring starter 我的项目时pom.xml文件谬误？(maven私服，本地库,maven update,网络)Spring Boot我的项目中反对的配置文件后缀有哪些?(.properties,.yml)SpringBoot 启动类的包扫描地位？(启动类所在包以及子包)SpringBoot我的项目中能够有多个启动类吗？(不能够)如何了解Spring框架?(资源整合框架,迷信利用对象-资源,低耦合)Spring治理bean对象时有什么劣势？（为bean赋予了更加高级的个性，懒加载，单例作用域，生命周期办法） Spring 框架中@Autowire注解形容属性时，依赖注入的规定是怎么的?链接：https://segmentfault.com/a/11...Spring 框架学习过程中学到了什么思维？(IOC,DI,池,低耦合,....) IOC的了解：管制反转的容器。把对象的获取的主动权交出去 DI: 依赖注入，通过在构建bean对象的时候，把数据退出到对象中，所谓的依赖的意思就是这里的数据有可能是通过其它的bean对象失去的。Spring容器中bean名字不同,但类型雷同的单例作用域配置能够有多个实例吗?1、应用@Qualifier注解指定具体bean名称 2、应用@Primary注解在申明bean的时候，通过将其中一个可选的bean设置为首选 BUG剖析*Maven我的项目的setting文件配置谬误创立我的项目时网络连接超时Maven我的项目的pom.xml文件报错空指针异样（NullPointerException-NPE）依赖注入失败找不到对应的Bean对象

关于springboot:Spring-Boot系列之读取配置

1 目标本节咱们要解决如下几个问题：如何应用Spring Boot读取配置文件？有哪些形式？罕用的几种数据结构，如字符串、整数、List、Map，如何配置？如何读取？如何自定义配置文件的门路？2 读配置文件Spring Boot默认的配置文件有两种格局： application.properties 和 application.yml 。查找程序是首先从application.properties 查找，如果找不到，再查找 application.yml。优先级：application.properties > application.yml 。 2.1 应用 @Value 读取配置配置如下： erwin.name=冯文议erwin.age=20erwin.sex=男erwin.english-name=Erwin Fengerwin.birthday=1992/02/26erwin.like=movie,game,music,tea,travelerwin.visitedCities=巴中,揭阳,广州,从化,成都,三亚,上海,杭州,北京erwin.moreOther={myWeb:'https://fengwenyi.com',github:'https://github.com/fengwenyi'}代码如下： package com.fengwenyi.spring_boot_config_sample.config;import lombok.Data;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.Configuration;import java.util.*;/** * @author Erwin Feng * @since 2020/8/11 */@Data@Configurationpublic class ReadConfigByValue { @Value("${erwin.name}") private String name; @Value("${erwin.age}") private Integer age; @Value("${erwin.sex}") private String sex; @Value("${erwin.english-name}") private String englishName; @Value("${erwin.birthday}") private Date birthday; @Value("${erwin.like}") private List<String> likes; @Value("#{'${erwin.visitedCities}'.split(',')}") private List<String> visitedCities; @Value("#{${erwin.moreOther}}") private Map<String, String> moreOther; } ...

关于springboot:Mybatis入门篇之结果映射你射准了吗

继续原创输入，点击上方蓝字关注我吧目录前言什么是后果映射？如何映射？别名映射驼峰映射配置文件开启驼峰映射配置类中开启驼峰映射resultMap映射总结高级后果映射关联(association) 例子关联的嵌套 Select 查问关联的嵌套后果映射总结汇合collection 汇合的嵌套 Select 查问汇合的嵌套后果映射总结前言上一篇文章介绍了Mybatis根底的CRUD操作、罕用的标签、属性等内容，如果对局部不相熟的敌人能够看Mybatis入门之基本操作。本篇文章持续解说Mybatis的后果映射的内容，想要在企业开发中灵便的应用Mybatis，这部分的内容是必须要精通的。什么是后果映射？简略的来说就是一条SQL查问语句返回的字段如何与Java实体类中的属性绝对应。如下一条SQL语句，查问患者的用户id，科室id，主治医生id： <select id='selectPatientInfos' resultType='com.xxx.domain.PatientInfo'> select user_id,dept_id,doc_id from patient_info; </select>Java实体类PatientInfo如下：@Datapublic class PatientInfo{ private String userId; private String deptId; private String docId;}程序员写这条SQL的目标就是想查问进去的user_id,dept_id,doc_id别离赋值给实体类中的userId,deptId,docId。这就是简略的后果映射。如何映射？Myabtis中的后果映射有很多种形式，上面会逐个介绍。别名映射这个简略，放弃查问的SQL返回的字段和Java实体类一样即可，比方下面例子的SQL能够写成：<select id='selectPatientInfos' resultType='com.xxx.domain.PatientInfo'> select user_id as userId, dept_id as deptId, doc_id as docId from patient_info; </select>这样就能和实体类中的属性映射胜利了。驼峰映射Mybatis提供了驼峰命名映射的形式，比方数据库中的user_id这个字段，可能主动映射到userId属性。那么此时的查问的SQL变成如下即可：<select id='selectPatientInfos' resultType='com.xxx.domain.PatientInfo'> select user_id,dept_id,doc_id from patient_info; </select>如何开启呢？与SpringBoot整合后开启其实很简略，有两种形式，一个是配置文件中开启，一个是配置类开启。配置文件开启驼峰映射只须要在application.properties文件中增加如下一行代码即可：mybatis.configuration.map-underscore-to-camel-case=true配置类中开启驼峰映射【简略理解，后续源码章节着重介绍】这种形式须要你对源码有肯定的理解，上一篇入门教程中有提到，Mybatis与Springboot整合后适配了一个starter，那么必定会有主动配置类，Mybatis的主动配置类是MybatisAutoConfiguration，其中有这么一段代码，如下： @ConditionalOnMissingBean这个注解的意思就是当IOC容器中没有SqlSessionFactory这个Bean对象这个配置才会失效;applyConfiguration(factory)这行代码就是创立一个org.apache.ibatis.session.Configuration赋值给SqlSessionFactoryBean。源码剖析到这，应该很分明了，无非就是本人在容器中创立一个SqlSessionFactory，而后设置属性即可，如下代码： @Bean("sqlSessionFactory") public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception { SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean(); //设置数据源 sqlSessionFactoryBean.setDataSource(dataSource); //设置xml文件的地位 sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(MAPPER_LOCATOIN)); //创立Configuration org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration(); // 开启驼峰命名映射 configuration.setMapUnderscoreToCamelCase(true); configuration.setDefaultFetchSize(100); configuration.setDefaultStatementTimeout(30); sqlSessionFactoryBean.setConfiguration(configuration); //将typehandler注册到mybatis sqlSessionFactoryBean.setTypeHandlers(typeHandlers()); return sqlSessionFactoryBean.getObject(); }留神：如果对SqlSessionFactory没有非凡定制，不介意重写，因为这会主动笼罩主动配置类中的配置。resultMap映射什么是resultMap？简略的说就是一个相似Map的构造，将数据库中的字段和JavaBean中的属性字段对应起来，这样就能做到一一映射了。上述的例子应用resultMap又会怎么写呢？如下：<resultMap id="patResultMap" type="com.xxx.domain.PatientInfo"> <id property="userId" column="user_id" /> <result property="docId" column="doc_id"/> <result property="deptId" column="dept_id"/></resultMap><select id='selectPatientInfos' resultMap='patResultMap'> select user_id,dept_id,doc_id from patient_info; </select>其实很简略，就是创立一个<resultMap>，而后<select>标签指定这个resultMap即可。<resultMap>的属性如下： ...

关于springboot:SpringBoot基础day03

理论开发中应用程序与数据库交互时，“取得连贯”或“开释资源”是十分耗费系统资源的两个过程，为了解决此类性能问题，通常状况咱们采纳连接池技术来重用连贯Connection对象。 Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商须要让本人的连接池实现这个接口。而后咱们的应用程序中耦合与这个接口，便能够不便的切换不同厂商的连接池，常见的连接池有DBCP、C3P0，DRUID,HikariCP等。 SpringBoot整合连接池过程 SpringBoot整合连贯原理：SpringBoot整合Mybatis框架Mybatis：Mybatis是一个优良的长久层框架，底层基于JDBC实现与数据库的交互。并在JDBC操作的根底上做了封装和优化，它借助灵便的SQL定制，参数及后果集的映射形式，更好的适应了以后互联网技术的倒退。 ** 在当今的互联网利用中我的项目，mybatis框架通常会由spring框架进行资源整合，作为数据层技术实现数据交互操作。 **

关于springboot:SpringBoot-2-项目的打包发布-加强

1 我的项目的打包公布我的项目不会以包或者类等的形式公布进来，一个我的项目若要公布那么就要打包成jar/war包的模式，在IDEA环境下开发的我的项目须要打包的话就要就要用到install,打完包会会在我的项目中生成一个target文件，外面蕴含对应我的项目的jar/war包，并且在maven本地仓库中也会生成对应的包，具体步骤见下图： 1.1 过程：Maven-->我的项目-->生命周期-->install 1.2 打包的后果在我的项目①target包中动静生成我的项目的jar/war包和绝对应的其余文件。②在本地仓库中也要生成一个jar/war包。留神：在本地文件中也生成一个jar/war包的起因？被其余我的项目或者模块依赖，在一个我的项目中有很多的模块而且它们也是极其简单的。 1.3 留神问题我的项目每次打包的时候先要install一下，因为我的项目如果产生扭转，在target和本地仓库中的jar/war包是以前的，并没有进行更新，install第二次低=第N次的install能够了解为我的项目的更新。 1.4 公布关上Doc命令窗口，进入我的项目被打包到的本地仓库的地位，输出java -java Demo01.jar我的项目就会主动公布。 1.5 留神1.jar/war文件的名字繁琐的话能够本人更改2.在文件的地位栏中输入cmd，就能够关上DOC命令窗口，并且已近进入改文件对应的地位。3.在我的项目打包部署时失效,如果不增加build,则程序公布时不然会报我的项目中没有main办法。 <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> 2 我的项目增强2.1 我的项目的热部署我的项目中的代码更改之后咱们不须要手动重启服务器，只须要保留，服务器就会主动启动更新我的项目，也就是说热部署能够简化操作，使得开发人员的效率进步，当然也须要较好的硬件环境。 2.1.1 增加jar包<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId></dependency>2.1.1 配置的批改Alt+Ctrl+Shift+/ 2.2 环境切换2.2.1 为何要进行环境的切换？我的项目上线的时候须要在生产环境下部署，然而咱们开发时是在测试换将下实现的，那么如果测试环境和生产环境不一样，就会使得我的项目报错无奈上线。 2.2.2 解决思路配置多个环境，即测试用测试的环境，上线公布用公布的环境。 2.2.3 边界YML文件配置多个环境其设置总结来讲就是三个步骤： 1 设置测试环境2 设置公布环境3 设置默认环境# 测试环境 /jt 端口号80 生产环境：/ 端口号 8080 配置必须实现#设定默认的环境spring: profiles: active: test #默认的环境---# yml 1.key-value构造# 2.key-value之间应用": "办法链接# 3.YML配置文件有缩进的成果.# 4.YML配置文件默认采纳utf-8编码.#定义环境的名称spring: profiles: prodserver: servlet: context-path: / #设定我的项目公布门路 port: 80#配置图片上传门路#image: #localDir: F:\FOREVERUPWARD\JAVA\JAVA_CGBTN200529_frame03\PICTURE#分隔线，即下面的一部分和上面的一部分没有任何关系---#设定环境的名称spring: profiles: testserver: servlet: context-path: /jt #设定我的项目公布门路 port: 8080测试环境 ...

关于springboot:SpringBoot项目依赖注入92之前

SpringBoot我的项目依赖注入1.Mysql Driver2.JDBC API3.增加Mybatis依赖： <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.3</version> </dependency>*配置： mybatis.configuration.default-statement-timeout=30 mybatis.configuration.map-underscore-to-camel-case=true 日志输入： logging.level.com.cy=DEBUG4.Spring MVC依赖: Web依赖：会配置一个内置的tomcat<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId></dependency>Thymeleaf依赖：<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId></dependency>*配置Thymeleaf的地址：spring.thymeleaf.prefix=classpath:/templates/pages/spring.thymeleaf.suffix=.html5.配置文件： spring.main.banner-mode=off spring.datasource.url=jdbc:mysql://localhost:3306/dbgoods?serverTimezone=GMT%2B8&characterEncoding=utf-8spring.datasource.username=rootspring.datasource.password=root spring mybatismybatis.mapper-locations=classpath:/mapper/goods/*.xml Spring loglogging.level.com.py=debug SpingMVC Tomcat:portserver.port=80server.servlet.context-path=/ Spring thymeleaf configspring.thymeleaf.cache=falsespring.thymeleaf.prefix=classpath:/templates/pages/spring.thymeleaf.suffix=.html management.endpoints.web.exposure.include=*

关于springboot:Spring-Boot-项目基础入门

spring boot 我的项目根底入门实现Goods我的项目的增删改查1)创立spring starter boot 我的项目2)增加依赖：jdbc,mysql,spring,mybatis,thymeleaf3)批改我的项目的application.properties文件配置端口号（能够在浏览器拜访时不写端口号）server.port=80(80端口号在拜访时能够省略)配置spring boot 与数据库的连贯spring.datasource.urlspring.datasource.usernamespring.datasource.password配置mybatis.mapper-location=classpath:/templates/pages/配置classpath:/mapper/*/*.xml配置.html4)创立pojo对象5)创立数据层接口用@Mapper形容该接口这里写映射（既增删改查的SQL语句及办法）6)创立业务层接口这里写业务办法7)创立业务层的实现类用@Service形容该类这里重写业务层接口的所有形象办法8)创立Controller类这里调用业务层实现类的办法做增删改查9)创立html,获取相应的数据及在页面上显示

关于springboot:如何理解Spring中的Autowired

@Autowired 简介@Autowired 注解用于形容类中的属性，构造方法，set办法，配置办法等，用于通知Spring框架依照指定规定为属性注入值(DI)。 @Autowired 利用入门基于如下API设计，进行代码实现进而剖析@Autowired利用剖析。(https://segmentfault.com/img/... 第一步：设计Cache接口 package com.cy.pj.common.cache;public interface Cache { }第二步: 设计Cache接口实现类WeakCache，并交给spring治理。 package com.cy.pj.common.cache; import org.springframework.stereotype.Component; @Component public class WeakCache implements Cache{ }第二步: 设计Cache接口实现类SoftCache，并交给spring治理。 package com.cy.pj.common.cache; @Componentpublic class SoftCache implements Cache{…}第三步：设计单元测试类 package com.cy.pj.common.cache;import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.boot.test.context.SpringBootTest;@SpringBootTest public class CacheTests { @Autowired @Qualifier("softCache") private Cache cache; @Test public void testCache() { System.out.println(cache); }}基于单元测试，剖析@Autowired利用（底层通过反射技术为属性赋值）。阐明：Spring框架在我的项目运行时如果发现由他治理的Bean对象中有应用@Autowired注解形容的属性，能够依照指定规定为属性赋值(DI)。其根本规定是：首先要检测容器中是否有与属性类型相匹配的对象，如果有并且只有一个则间接注入。其次，如果检测到有多个，还会依照@Autowired形容的属性名查找是否有名字匹配的对象，有则间接注入，没有则抛出异样。最初，如果咱们有明确要求，必须要注入类型为指定类型，名字为指定名字的对象还能够应用@Qualifier注解对其属性或参数进行形容(此注解必须配合@Autowired注解应用)。@Autowired 利用进阶@Autowired 注解在Spring治理的Bean中也能够形容其构造方法，set办法，配置办法等，其规定仍旧是先匹配办法参数类型再匹配参数名，基于如下图的设计进行剖析和实现：第一步：定义SearchService类并交给Spring治理 package com.cy.pj.common.service;@Componentpublic class SearchService{ private Cache cache; @Autowired public SearchService(@Qualifier("softCache")Cache cache){ this.cache=cache; } public Cache getCache(){ return this.cache; }}@Qualifier能够形容构造方法参数，但不能够形容构造方法。第二步：定义SearchServiceTests单元测试类。 ...

关于springboot:SptingBoot入门3

SptingBoot的我的项目业务加强和测试1.如果一个接口有两个实现类，并且都（@Component）都交给bean治理，当测试类从bean中获取（@AutoWired）这个接口对象时，会呈现什么问题？package com.py.pj.commom.cache;public interface Cache {}package com.py.pj.commom.cache;import org.springframework.stereotype.Component;@Componentpublic class SoftCache implements Cache{} package com.py.pj.commom.cache;import org.springframework.stereotype.Component;@Componentpublic class WeakCache implements Cache{}package com.py.pj.commom.service;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.stereotype.Component;import com.py.pj.commom.cache.Cache;@Componentpublic class SearchService { private Cache cache; public SearchService(Cache cache) { this.cache = cache; } // 外界通过get取得spring容器注入的cache对象 public Cache getCache() { return cache; }}测试类 @SpringBootTestpublic class TestCache { @Autowired @Qualifier("softCache") private Cache cache; @Test void testCache() { System.out.println(cache); }} 呈现相似谬误的起因：名为Cache的bean对象在默认的singleton作用域中有两个值softCache、weakCache。不晓得取哪一个造成的谬误。有三种解决方案：须要用到@Autowired和@Qualifier，@Qualifier需和@Autowired配合应用。（1）间接在SearchService类中@Autowired给Cache注入值，并应用@Quailfier()抉择注入类型的属性，在这里咱们能够抉择softCache和weakCache其中一个。 @Autowired @Qualifier("softCache") private Cache cache; public SearchService() { }（2）第二种是借助set办法和无参结构，给Cache注入为weakCache的值 ...

关于springboot:SPRINGBOOT基础05

Springboot根底 Day05static文件夹与templates文件夹的区别templates 里的资源须要tymleaf帮忙解析能力拜访static 里的寄存的是动态资源能够间接拜访利用 tymeleaf 在html中显示出数据@{门路/{变量名(变量名=${域名.办法名})th:each 展现一组数据这是遍历的代码,能够参考<tr th:each="g:${goods}"> <td th:text="${g.id}">1</td> <td th:text="${g.name}">AAA</td> <td th:text="${g.remark}">AAA</td> <td th:text="${#dates.format(g.createdTime, 'yyyy/MM/dd HH:mm')}">2020/08/31</td> <td><a href="#" th:href="@{/goods/doDeleteById/{id}(id=${g.id})}">delete</a></td> <td><a href="#" th:href="@{/goods/doFindById/{id}(id=${g.id})}">update</a></td></tr>

关于springboot:Spring-Boot业务分析

业务形容基于Spring,MyBatis,SpringBoot,Thymeleaf技术实现商品模块的增删改查操作。我的项目环境初始化筹备工作1. MySQL(5.7)2. JDK (1.8)3. Maven (3.6.3)4. STS(4.7.1)数据库初始化关上mysql控制台,而后按如下步骤执行goods.sql文件。第一步:登录mysql。 mysql –uroot –proot第二步:设置控制台编码方式。 set names utf8;第三步:执行goods.sql文件（切记不要关上文件复制到mysql客户端运行）。 source d:/goods.sql其中goods.sql文件内容如下： drop database if exists dbgoods;create database dbgoods default character set utf8;use dbgoods;create table tb_goods( id bigint primary key auto_increment, name varchar(100) not null, remark text, createdTime datetime not null)engine=InnoDB;insert into tb_goods values (null,'java','very good',now());insert into tb_goods values (null,'mysql','RDBMS',now());insert into tb_goods values (null,'Oracle','RDBMS',now());insert into tb_goods values (null,'java','very good',now());insert into tb_goods values (null,'mysql','RDBMS',now());insert into tb_goods values (null,'Oracle','RDBMS',now());insert into tb_goods values (null,'java','very good',now());创立我的项目并增加依赖第一步：基于start.spring.io 创立我的项目并设置根本信息 ...

关于springboot:SpringBoot注解

@Component(@Service,@Controller)是Sring中用于形容Bean类的一个注解，用于通知Spring这个类的实例由Spring创立和治理，默认会将对象存储到池（Bean池）中 @Component（“softCache”）形容bean时，给bean起名字为softCache @SpringBootTest 注解用于通知Spring框架，次测试类交给Spring治理 @Autowired 注解形容属性，用于通知Spring框架要为此属性注入一个值 @Lazy 注解同于形容类，其目标是通知谁陪你过框架此类反对提早加载，通常会配合单例作用域应用，默认是true--value==true @Scope 是Spring中用于定义Bean对象作用域的一个注解，罕用值有： 1、singleton（整个内存有一份Bean实例,此实例何时创立与类的提早加载个性配置无关，此实例创立当前，生命周期会由spring框架治理） 2、prototype(每次获取都会创立新实例，此实例会在须要时创立与lazy个性无关，这个实例创立当前，不会交给spring治理，spring能够对其初始化，但不负责销毁。)等。 @SpringBootApplication 注解形容的类是我的项目的启动入口 JVM参数：跟踪类加载： -XX:+TraceClassLoading @PostConstruct 注解用于形容bean对象生命周期办法中的初始化办法，此办法会在对象的构造方法之后执行(是对象创立当前的初始化) @PreDestroy 注解用于形容Bean对象生命周期办法中的销毁办法，此办法会在对象销毁之前执行（当作用域为prototype时，此办法不会执行） @Param 注解形容参数 @Qualifier 注解形容的属性，参数或办法，能够依照指定规定为属性赋值（DI），此注解必须配合@Autowired注解应用 @Mapper 示意这个类属于数据层是由MyBatis框架中定义的一个形容数据层接口的的注解(所有的注解只起到一个描述性的作用),用于通知Spring框架此接口的实现由mybatis创立，并将其实现类对象存储到spring容器. @Controller 示意这个类属于管制层 @RequestMapping 后加地址 @PathVariable("...")前面加门路的变量,如果该门路只有一个变量,能够只写该注解

关于springboot:SpringBoot注解

@Component 是Sring中用于形容Bean类的一个注解，用于通知Spring这个类的实例由Spring创立和治理，默认会将对象存储到池（Bean池）中@Component（“softCache”）形容bean时，给bean起名字为softCache@SpringBootTest 注解用于通知Spring框架，次测试类交给Spring治理@Autowired 注解形容属性，用于通知Spring框架要为此属性注入一个值@Lazy 注解同于形容类，其目标是通知谁陪你过框架此类反对提早加载，通常会配合单例作用域应用，默认是true--value==true@Scope 是Spring中用于定义Bean对象作用域的一个注解，罕用值有：1、singleton（整个内存有一份Bean实例,此实例何时创立与类的提早加载个性配置无关，此实例创立当前，生命周期会由spring框架治理） 2、prototype(每次获取都会创立新实例，此实例会在须要时创立与lazy个性无关，这个实例创立当前，不会交给spring治理，spring能够对其初始化，但不负责销毁。)等。@SpringBootApplication 注解形容的类是我的项目的启动入口JVM参数：跟踪类加载： -XX:+TraceClassLoading@PostConstruct 注解用于形容bean对象生命周期办法中的初始化办法，此办法会在对象的构造方法之后执行(是对象创立当前的初始化)@PreDestroy 注解用于形容Bean对象生命周期办法中的销毁办法，此办法会在对象销毁之前执行（当作用域为prototype时，此办法不会执行）@Param 注解形容参数@Qualifier 注解形容的属性，参数或办法，能够依照指定规定为属性赋值（DI），此注解必须配合@Autowired注解应用@Mapper 示意这个类属于数据层是由MyBatis框架中定义的一个形容数据层接口的的注解(所有的注解只起到一个描述性的作用),用于通知Spring框架此接口的实现由mybatis创立，并将其实现类对象存储到spring容器.@Controller 示意这个类属于管制层@Service 将类交给Spring治理，创立@RequestMapping 后加地址

关于springboot:Spring-Boot简单的增删改查

在pom.xml增加相应的依赖<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> <exclusions> <exclusion> <groupId>org.junit.vintage</groupId> <artifactId>junit-vintage-engine</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.3</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>  <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> </dependencies>配置文件配置数据库等#server server.port=80 #我的项目名：server.servlet.context-path #spring dataSource spring.datasource.url=jdbc:mysql:///dbgoods?serverTimezone=GMT%2B8&characterEncoding=utf8 spring.datasource.username=root spring.datasource.password=root mybatis.mapper-locations=classpath:/mapper/*/*.xml #spring log logging.level.com.cy=debug #spring thymeleaf（如果没有配置也会默认配置，在默认配置中prefix默认值为classpath:/templates/,后缀默认为.html） #不必重启服务器，网页就能刷新 spring.thymeleaf.cache=false spring.thymeleaf.prefix=classpath:/templates/pages/ spring.thymeleaf.suffix=.html数据层增加相应注解实现sql语句（或者通过xml配置来实现）数据层封装了商品信息，并提供get和set办法，为Goods类 1.查问所有数据 @Select("select * from tb_goods") List<Goods> findAll();2.依照id删除数据 ...

关于springboot:Java-Spring-Boot小结02

Spring Boot 整合MyBatis框架*概述 Mybatis是一个优良的长久层框架，底层基于JDBC实现与数据库的交互。并在JDBC操作的根底上做了封装和优化，它借助灵便的SQL定制，参数及后果集的映射形式，更好的适应了以后互联网技术的倒退*例：实现商品信息的查问，并将查问到的数据在测试类中进行输入第一步：定义pojo对象(Goods)用于存储从数据库查问到的商品信息. 第二步：定义dao办法办法，用于查询数据库所有商品数据。第三步：定义业务层接口以及实现类，而后在类中增加商品查问的业务办法。第四步：定义单元测试类，对业务层办法进行单元测试 Spring Boot 整合SpringMVC利用*概述 MVC（Model–view–controller）是软件工程中的一种软件架构模式，基于此模式把软件系统分为三个根本局部：模型（Model）、视图（View）和控制器（Controller）。目标是通过这样的设计使程序结构更加简洁、直观，升高问题的复杂度*组成部分的职责为：视图（View） - UI设计人员进行图形界面设计，负责实现与用户交互。控制器（Controller）- 负责获取申请，解决申请，响应后果。模型（Model） - 实现业务逻辑，数据逻辑实现。 *MVC设计思维 Servlet充当MVC中的Controller,负责调用model解决业务，负责转发或重定向某个页面，在页面(view)上出现数据。模块封装了对Servlet的技术的利用，简化了程序员对申请和响应过程中数据的解决。*Spring MVC （是Spring 框架中基于MVC实现的用于解决Web申请的模块）--繁难架构：*外围组件 DispatcherServlet ：前端控制器, 解决申请的入口。 HandlerMapping：映射器对象, 用于治理url与对应controller的映射关系。 Interceptors：拦截器,实现申请响应的共性解决。 Controller：后端控制器-handler, 负责解决申请的管制逻辑。 ViewResolver：视图解析器,解析对应的视图关系(前缀+viewname+后缀) Spring MVC 入门实际*步骤：第一步：编写一个类（GoodsController）并将其交给spring治理--*package com.cy.pj.goods.controller;@Controller@RequestMapping("/goods/")public class GoodsController { @RequestMapping("doGoodsUI")public String doGoodsUI() { return "goods";}}* 第二步：须要在/templates/pages/目录下创立goods.html-- 第三步：启动服务器(默认我的项目嵌入的是tomcat)，关上浏览器进行拜访测试。*练习：易错剖析*1.查看url输出开释正确查看你拜访的controller对象开释交给了Spring治理小结*rest格调：一种软件架构编码格调，其设计的次要目标是在异构零碎之间实现兼容(跨平台)*可变参数能够看成是一个非凡数组，目标是简化类中办法名雷同，参数类型雷同，但参数个数不同的这样的一些重载办法定义

关于springboot:springboot测试

1)返回的viewname会给谁?谁调用doGoodsUI办法就给谁(DispatcherServlet) 2)谁负责解析viewname?ViewResolver(ThymleafViewResolver) 3)viewname解析的后果会影响到哪里?(prefix+viewname+suffixuffix会影响到客户端) static目录为动态资源(html/css/js)目录,此目录中的资源能够在浏览器地址间接拜访templates目录要通过thymleaf解析 sp04是我的项目名return"redirect:doGoodsUI";和return"redirect:/doGoodsUI"的区别如果加斜杠会加到我的项目名前面加到/sp04前面没有加斜杠会加到最初一个斜杠前面@pathVariable注解对办法参数进行形容(办法参数名须要和URL中的{}外部变量名雷同)

关于springboot:Spring-Boot快速入门之十四Servlet-过滤器

【注】本文译自： https://www.tutorialspoint.co..._boot/spring_boot_servlet_filter.htm 过滤器是一种拦挡利用中 HTTP 申请和响应的对象，应用过滤器，你能够执行以下两种情景下的两种操作：在发送申请到到控制器之前在发送响应到客户端之前上面的示例代码是以 @Component 注解的类来实现 Servlet 过滤器： public class SimpleFilter implements Filter { @Override public void destroy() {} @Override public void doFilter (ServletRequest request, ServletResponse response, FilterChain filterchain) throws IOException, ServletException {} @Override public void init(FilterConfig filterconfig) throws ServletException {}}上面的示例代码展现了在发送申请到控制器之前，从 ServletRequest 对象读取近程主机和地址：在 doFilter() 办法中，咱们加了 System.out.println 语句打印近程主机和地址： package com.tutorialspoint.demo; import java.io.IOException;import javax.servlet.Filter;import javax.servlet.FilterChain;import javax.servlet.FilterConfig;import javax.servlet.ServletException;import javax.servlet.ServletRequest;import javax.servlet.ServletResponse; import org.springframework.stereotype.Component; @Componentpublic class SimpleFilter implements Filter { @Override public void destroy() {} @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterchain) throws IOException, ServletException { System.out.println("Remote Host:"+request.getRemoteHost()); System.out.println("Remote Address:"+request.getRemoteAddr()); filterchain.doFilter(request, response); } @Override public void init(FilterConfig filterconfig) throws ServletException {}}在 Spring Boot 主利用类文件中，咱们加了简略 REST 端点返回 “Hello World” 字串： ...

关于springboot:SpringBoot-RabbitMQ消息队列的重试超时延时死信队列

明天介绍应用SpringBoot实现RabbitMQ音讯队列的高级用法。 MQ装置主动创立音讯重试音讯超时死信队列延时队列一、RabbitMQ的装置家喻户晓，RabbitMQ的装置绝对简单，须要先装置Erlang，再按着对应版本的RabbitMQ的服务端，最初为了方便管理还须要装置rabbitmq_management治理端插件，偶然还会呈现一些装置配置问题，故十分复杂。在开发测试环境下应用docker来装置就不便多了，省去了环境和配置的麻烦。 1. 拉取官网imagedocker pull rabbitmq:management2. 启动RabbitMQdocker run -dit --name MyRabbitmq -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin -p 15672:15672 -p 5672:5672 rabbitmq:managementrabbitmq:management: image:tag--name:指定容器名；-d:后盾运行容器；-t:在新容器内指定一个伪终端或终端；-i:容许你对容器内的规范输出 (STDIN) 进行交互；-p:指定服务运行的端口（5672：利用拜访端口；15672：控制台Web端口号）；-e:指定环境变量；（RABBITMQ_DEFAULT_USER：默认的用户名；RABBITMQ_DEFAULT_PASS：默认用户名的明码）；至此RabbitMQ就装置启动实现了，能够通过http://localhost:15672 登陆治理后盾，用户名明码就是下面配置的admin/admin 二、应用SpringBoot主动创立队列1. 引入amqp包<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId></dependency>2. MQ配置bootstrap.yml 配置 spring: rabbitmq: host: localhost port: 5672 virtual-host: / username: admin password: admin listener: simple: concurrency: 5 direct: prefetch: 10concurrency：每个listener在初始化的时候设置的并发消费者的个数prefetch：每次从一次性从broker外面取的待生产的音讯的个数 rabbitmq-spring.xml配置 <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/rabbit http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">  <rabbit:queue name="login-user-logined" />  <rabbit:topic-exchange name="login_barryhome_fun"> <rabbit:bindings>  <rabbit:binding queue="login-user-logined" pattern="login.user.logined"/> </rabbit:bindings> </rabbit:topic-exchange></beans>rabbit:topic-exchange：申明为topic音讯类型pattern="login.user.logined"：此处是一个表达式，可应用“*”示意一个词，“#”示意一个或多个词 ...

关于springboot:Spring-Boot快速入门之十三-拦截器

【注】本文译自： https://www.tutorialspoint.com/spring_boot/spring_boot_interceptor.htm 在以下两种状况下，能够在 Spring Boot 中应用拦截器来执行操作：发送申请到控制器之前发送响应到客户端之前譬如，能够应用拦截器在发送申请到控制器之前增加申请头，并在发送响应到客户端之前增加响应头。要用拦截器，你须要创立 @Component 类，并且要实现 HandlerInterceptor 接口。上面是应用拦截器要晓得的三个办法： preHandle() 办法：用于在发送申请到控制器之前执行操作。这个办法该当返回 true 以响应客户端。postHandle() 办法：用于在发送响应到客户端之前执行操作。afterCompletion() 办法：用于在申请和响应实现之后执行操作。察看以下代码以加深了解： @Componentpublic class ProductServiceInterceptor implements HandlerInterceptor { @Override public boolean preHandle( HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 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 exception) throws Exception {}}还要通过 WebMvcConfigurerAdapter 用 InterceptorRegistry 注册这个拦截器： ...

关于springboot:SpringBoot

Day01学习总结一.SpeingBoot疾速入门1.Spring外围特色SpringBoot外围个性: Spring boot是一个脚手架，构建于Spring框架(Framework)根底之上，基于疾速构建理念，提供了主动配置性能，可实现其开箱即用个性（创立完一个根本的我的项目当前，可零配置或者大量配置即可运行咱们的我的项目），其外围次要有如下几个方面：起步依赖(Starter Dependency)-我的项目创立时底层帮你关联依赖。主动配置(Auto Configuration)。健康检查(Actator)-监控。2.SpringBoot我的项目构造剖析3.SpringBoot我的项目构造剖析SpringBoot 我的项目在启动时，首先基于启动入口类上的注解形容，进行主动配置并扫描指定包以及子包中的类进行加载，而后检测类上是否有Spring框架中指定的注解形容（例如@Component,@Controller,@Service等）。如果有，则将类交给Spring框架中的BeanFactory工厂接口的实现类对象，此工厂对象会基于反射创立Bean的实例，假如此Bean指定了生命周期办法，还会调用生命周期办法。当实例创立当前，Spring框架还会基于类的作用域形容，将实例存储到不同作用域的容器中。以实现Bean对象的迷信利用。 4.SpringBoot 注解解释@Component是Spring中用于形容Bean类的一个注解.用于通知Spring这个类的实咧由Spirng创立,当此对象由Spring创立和治理时,默认将对象贮存到Bean池中. @SpringBootTest用于通知Spring框架,此测试类交给spring治理 @Autowired注解形容属性,用于通知spring框架为此属性注入一个值? @Lazy注解用于形容类,其目标是通知Spring框架此类反对提早加载,通常配合单例作用域应用. @Scope是spring中用于定义Bean对象作用域的一个注解,其罕用的价值有如下:@Scope("singleton")整个内存有一份Bean实咧,此实咧何时创立与类的提早加载个性配置无关,此实咧创立当前,生命周期会由Spring框架治理@Scope("Prototype")每次都会创立新实咧,此实咧会在须要创立与lazy个性无关,这个实咧创立当前,不会交给spring治理,spring能够对其初始化,但不负责销毁. @PostConstruct注解用于形容Bean对象生命周期办法中的初始化办法，此办法会在对象的构造方法之后执行(是对象创立当前的初始化)。 @PreDestroy注解用于形容Bean对象生命周期办法中的销毁办法，此办法会在对象销毁之前执行（当作用域为prototype时，此办法不会执行）。 4.SpringBoot创立我的项目及测试业务测试流程原理剖析:思考:(1)@Autowired注解的利用规定?(2)@Qualifier注解的作用是什么?@Autowired由spring框架定义，用于形容类中属性或相干办法(例如构造方法)。Spring框架在我的项目运行时如果发现由他治理的Bean对象中有应用@Autowired注解形容的属性或办法，能够依照指定规定为属性赋值(DI)。其根本规定是：首先要检测容器中是否有与属性或办法参数类型相匹配的对象，如果有并且只有一个则间接注入。其次，如果检测到有多个，还会依照@Autowired形容的属性或办法参数名查找是否有名字匹配的对象，有则间接注入，没有则抛出异样。最初，如果咱们有明确要求，必须要注入类型为指定类型，名字为指定名字的对象还能够应用@Qualifier注解对其属性或参数进行形容(此注解必须配合@Autowired注解应用)。具体过程可参考图-18的设计进行自行尝试和实际。

关于springboot:断点-两个映射报错-绑定错误

断点罕用设置映射配置报错解决映射配置报错绑定谬误找不到参数

关于springboot:SpringBoot整合mybatis

由@Mapper注解形容数据长久层拜访的接口会由mubatis底层为其创立实现类(代理类).spring注入的对象即这个代理类,治理还是由spring治理.该类外部实现了:(1)取得一个曾经存在的数据源(所以在此之前须要配置连接池)(2)创立一个SqlSessionFactory(3)基于SqlSessionFactory创立一个SqlSessionTemplate(线程平安的)(4)主动扫描映射器(sql),并将它们与SqlSessionTemplate连贯简略的SQL映射能够间接通过注解(@Delete)间接写在接口办法的下面.简单的SQL映射就要写在xml映射文件中,同一个mapper中不能呈现反复id.在JDK8以前,collection里要么写array或者接口办法里加@Param("ids")注解,否则接管不到参数ids.耦合于接口.

关于springboot:spring-boot-注解

@Mapper用于(做标记)数据层拜访接口,用于通知mybatis框架,应用此注解的接口由底层为创立实现类,在实现类中基于mybatisAPI实现与数据库的交互.这个类的对象最初会交给spring治理办法(int... ids)可变参数能够看成一个非凡的数组,目标是简化类中办法名雷同参数类型雷同,但参数个数不同的怎么的一些重载办法定义

关于springboot:SpringBoot入门

SpringBoot 简介概述 Springboot是一个基于spring框架构建脚手架,基于疾速构建理念,提供了主动配置性能,实现其开箱即用的个性(创立一个我的项目是可零配置或大量配置就能运行咱们的我的项目). springboot是一个资源整合框架,通过Spring框架能够将很多资源整合(例如:本人写的对象,第三方提供的对象,如连接池等整合到一起),便于应用. 能够对Spring框架治理的对象(Bean)提供懒加载策略,作用域,以及生命周期办法,实现对象对系统资源的无效应用.还可基于用户的设计治理对象与对象之间的关系,以升高对象见得耦合性,进步程序和可维护性和可扩展性.外围个性其外围个性次要有:启动依赖: 我的项目创立框架时底层主动关联依赖主动配置-开箱即用健康检查-系统监控SpringBoot 环境搭建基于IDEA创立springboot我的项目1.file -->new ->project 抉择Empty Project,点击next 2.输出工程名,点击finish 3.抉择modules,点击 + 号之后抉择 new moudle 4.如下图抉择后点击next 5.按我的项目填写完后,点击next 6.抉择要我的项目须要增加的依赖,点击下一步 7.输出项目名称,点击实现即可 Springboot 总结1.SpringBoot是什么?SpringBoot是一个基于Spring的轻量级的资源整合框架,它不仅继承了Spring框架原有的个性,可尽可能的通过简化配置,简化了Spring利用的整个搭建和开发过程,提供了主动配置,实现其开箱即用的个性(创立一个我的项目可零配置或尽可能少的配置,就可运行咱们的我的项目)2.Springboot的外围劣势,应用SpringBoot的益处 1.SpringBoot的开箱即用个性,在开发过程中,可通过向Maven的 pom.xml文件增加相干的依赖包,和增加相应的注解来治理bean对象,不必配置繁琐的xml文件.2.SpringBoot框架可为由它治理的Bean对象提供提早加载(懒加载)策略,作用域,生命周期办法,正当的治理对象,更无效的应用系统资源3.SpringBoot框架还能够基于用户的设计正当的治理对象与对象间的关系,缩小对象间的耦合性,进步程序的可维护性和可扩展性.3.SpringBoot的启动过程 4.SpringBoot我的项目启动时,Bean对象的初始化过程是怎么样的?5.SpringBoot我的项目启动时,Bean对象的依赖注入过程是怎么样的?6.Spring 框架中Bean对象有什么个性提早加载/懒加载作用域生命周期办法 Spring框架在为bean创建对象是会赋予其个性:懒加载策略(提早加载),作用域生命周期发办法,便于管理bean对象和无效的利用系统资源 @Lazy 此注解示意提早加载,按需加载,先不创建对象,在须要时再创建对象. 1)长处:能够优化系统资源的利用 2)毛病:须要时再加载会影响加载速度 3)应用场景:大资源,应用频度低的资源适宜懒加载 4)实现办法:在须要懒加载的对象上加@Lazyzhujie 即可@Scope()作用域: Spring框架为对象提供作用范畴,其生命周期办法只在作用作用域内无效长处:让对象在无效范畴作用,尽量管制对象的创立和销毁,以保障程序高效低耗的运行毛病:框架底层设计难度会加大，利用不纯熟会导致作用域抵触。实现办法:在须要设定作用域的类上加@Scope()注解 1)**单例作用域**@Scope("singleton")作用域的对象在内存中只有一份,通过共享设计(Bean池)实现对象的可重用性何时创立由懒加载个性决定,何时销毁由spring框架决定,个别在容器销毁时销毁实用于应用频度高的对象 2)**多例作用域**@Scope("prototype")多例作用域，此作用域的对象在须要时创立(与懒加载个性无关)，每次从容器获取都是一个新的对象，且这些对象spring框架不负责销毁。适宜利用频度比较低的对象,实用于应用频度低的对象~~~~。 **生命周期办法:** 每个对象都有生命周期，但不见得每个对象都会设置生命周期办法,生命周期办法是在对象生命周期过程中要执行的一些办法。**@PostConstruct** 注解形容的办法会在对象构建当前执行,用于执行一些初始化操作**@PreDestroy** 注解形容的办法会在单例对象销毁之前执行，spring容器在销毁之前会先将容器(Bean池)中的对象进行移除，在移除对象时，如果对象中定义了生命周期销毁办法，此时还会调用对象的生命周期销毁办法(在这样的办法中能够做一些资源开释操作)。

关于springboot:Springboot对连接池的整合

连接池用于哪些方面，什么状况下须要用到连接池，连接池的呈现是基于什么背景创立的

关于springboot:SpringBootDay02

@Autowired@Autowired注解由spring框架定义，能够形容属性，set办法和构造方法，其中形容构造方法时能够省略。@Autowired注解为对象注入值时默认名称为类名首字母小写。@Autowired注解为属性注入值时：先判断属性类型，类型不匹配时会报 NoSuchBeanDefinitionException 谬误同一类型有多个对象时，再依据指定的名称查找，如果没有指定名称时会报 NoUniqueBeanDefinitionException 谬误也能够应用@Qualifier注解找指定名字的类为属性注入值，@Qualifier注解能够形容属性和个别办法，但不能润饰构造方法，用在构造方法中式须要写在形参后面再启动类的子包下定义一个接口Cache，在Cache接口所在包定义两个类SoftCache和WeakCache实现Cache接口并交给Spring框架治理，定义一个业务类SearchService交给Spring框架治理，实现代码如下：

关于springboot:SpringBoot中Autowired注解介绍

@Autowired由Spring框架定义，用于形容类中的属性后者办法（构造方法，set办法）。Spring框架在我的项目运行时如果发现由它治理的Bean对象中有应用@Autowired注解形容的属性或者办法，会依照指定规定为属性赋值（DI）。注入规定首先检测容器内是否有与属性或办法参数类型相匹配的对象，如果有并且只有一个就间接将这个类型的对象生成注入到属性或办法参数中。证实此论断的办法首先咱们创立一个接口，因为是测试用的所以接口中能够不必写办法~~~~ 再创立一个实现此接口的类比方SoftCache~~~~ 在该类下面增加一个@Component注解，用来示意该类的对象交给Spring框架来治理（创立，应用，存储，销毁）。而后咱们再写一个测试类用来测试@Autowried这个注解的作用~~~~ 在这个测试类下面要写上这个@SpringBootTest这个注解，示意该测试类由spring框架治理，然而这个类的对象不会存在Bean池中，因为测试类的作用域默认是多例模式（prototype）,在类中申明一个属性，属性类型为刚刚创立的接口类型，这里的属性名能够先随便。再创立一个办法，办法下面要增加注解@Test示意单元测试,办法体里的内容是输入这个属性的值，如果属性没有赋值则输入的值为null。这个时候咱们运行testCache这个办法，控制台打印输出后果为null。因为咱们没有给这个属性下面增加一个@Autowried注解，也没有在这个属性名字前面给它赋值，所以打印输出的后果是默认值null（援用类型变量）解决办法能够在该属性下面增加一个@Autowired正文，而后spring框架就会为咱们生成这个属性类型的实现类对象再打印输出后果是：输入的后果是这个对象的实现类名字和地址值。FAQ 1）当一个接口的实现类有多个时，这个接口类型的属性会怎么创建对象呢? 创立一个新的实现类，实现Cache接口,同样的在该类下面增加一个注解@Component示意将这类的对象交给spring治理，而后运行Test办法。 2）当一接口的实现类不止一个时，如果咱们不指定生成哪个实现类类型，Test运行后会报错: No qualifying bean of type 'com.cy.pj.common.cache.Cache' available: expected single matching bean but found 2: softCache,weakCache 该谬误的意思是，该属性能够创立的实现类不惟一，也就是有多个实现类，Spring框架底层不晓得你想要哪个实现类对象，所以咱们须要应用@Qualifier注解,这个注解作用是来指定你要创立的实现类是哪个。 @Qualifier注解里能够写你想要的实现类类名首字母小写其它该大写的中央大写（驼峰命名法）这样spring框架就晓得你想要哪个实现类生成对象,打印输出的后果是。留神@Qualifer外面写的实现类肯定要是实现了你申明的属性的类型的实现类才行，否则会报错。并且此注解要配合@Autowired注解应用，否则无奈注入值，输入还是null。如果不想用@Qualifer还有另一种写法就是将申明的属性的属性名写成实现类的类名同样的首字母小写其它该大写的中央大写。无参结构注入 @Autowired还能够使用在构造方法上（无参，有参都能够），咱们来测试这个办法，首先从新创立一个类不须要实现Cache接口，同样的在这个类上加上一个@Component注解让spring框架来治理这个类的对象，在这个类中咱们申明一个Cache接口类型的属性，并写一个无参构造方法，和一个返回值是Cache类型的办法。而后咱们在写一个测试类用来测试SeaSerivce这个类是否能注入值，这个测试类下面要写一个@SpirngBootTest注解示意这个测试类交个Spring框架治理，这个测试类里申明一个SeaSerivce类型的属性因为这个类型的类不是接口所以能够创立这个类的对象（由Spring容器创立）。属性上要加上@Autowired注解，而后在写一个测试方法，办法体的内容是输入打印在SerSerivce类中Cache这个接口类的属性的值，通过咱们在SeaSerivce类中提供的get办法。输入打印后咱们看到打印的后果为null，并且除了无参构造方法执行了，还另外执行了一个咱们没有写的办法就是setCache办法。当咱们在调用getCache这个办法时Spring框架会先扫描被Component注解过的所有类，在扫描这些类上面是否有@Autowired注解有的话就为他们赋值。因为咱们的Cache cache这个属性上没有写@Autowired注解所以没有主动注入值，打印输出后果为空。如果咱们间接写上@Autowired在这个属性上，运行后会报错，起因和下面的谬误是一样的非惟一的实现类。所以咱们要用set办法来指定用哪个实现类。留神要把属性下面的@Autowired正文或者删除掉，否则Spring扫描到后会间接报错不会持续扫描上面的内容，报错起因也是非惟一实现类。在set办法上增加一个@Autowired注解并且在参数中要应用@Qualifier指定哪个实现类，个别无参结构会配合set办法应用。 ...

关于springboot:springboot

@component省略名字,bean的默认名字为类名首字母小写@component形容类时,用于通知spring框架,有spring构建此类对象.1)spring框架如何为咱们的类型构建对象?通过工厂加反射2)反射构建对象时要用对应的API@autowired形容构造方法时@autowired注解能够省略

关于springboot:SpringBoot数据库连接池常用配置

创立yml配置文件，退出如下配置即可： spring: datasource: driver-class-name: com.mysql.jdbc.Driver username: root password: root url: jdbc:mysql://localhost:3306/zzz?characterEncoding=utf8&useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true type: com.alibaba.druid.pool.DruidDataSource # 上面为连接池的补充设置，利用到下面所有数据源中 # 初始化大小，最小，最大 initial-size: 5 min-idle: 5 max-active: 20 # 配置获取连贯期待超时的工夫 max-wait: 60000 # 配置距离多久才进行一次检测，检测须要敞开的闲暇连贯，单位是毫秒 time-between-eviction-runs-millis: 60000 # 配置一个连贯在池中最小生存的工夫，单位是毫秒 min-evictable-idle-time-millis: 300000 validation-query: SELECT 1 FROM DUAL test-while-idle: true test-on-borrow: false test-on-return: false # 关上PSCache，并且指定每个连贯上PSCache的大小 pool-prepared-statements: true # 配置监控统计拦挡的filters，去掉后监控界面sql无奈统计，'wall'用于防火墙 max-pool-prepared-statement-per-connection-size: 20 filters: stat,wall use-global-data-source-stat: true # 通过connectProperties属性来关上mergeSql性能；慢SQL记录 connect-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

关于springboot:SpringBoot基础入门2Day02笔记

SpringBoot根底入门2_Day02笔记XML的语法规定所有XML 元素都须有敞开标签XML 标签对大小写敏感在XML 中,所有元素都必须彼此正确地嵌套。XML 文档必须要有根元素XML 的属性值须加引号空格会保留,不想html会删除JVM参数--跟踪类加载run Configerations-->>Arguments -->>VM arguments输出:-XX:+TraceClassLoading下面的框对应的就是main办法里穿的String数组args main办法里的args是JVM调用传入的,和Spring无关敞开Spring Banner 画面conspring.main.banner-mode=off CommandLiner接口CommandLineRunner 接口的 Component 会在所有 Spring Beans 都初始化之后，SpringApplication.run() 之前执行适宜初始化,执行程序总结1.先加载Component >> 2.再执行接口里的run办法 >> 最初再执行main办法或者是Test办法 @Autowired注解主动为该属性注入一个值前提是该属性所属的类是归于spring框架来治理,@Component/@Service/@Controller/等等(打印该属性,调用该属性所属类的toString办法) 我的项目启动过程找到我的项目的入口类（应用了@SpringBootApplication注解形容），而后运行启动类，检测启动过程，SpringBoot在启动时，控制台会呈现Spring标识我的项目启动时产生了什么呢？首先基于启动入口类上的注解形容，进行主动配置并扫描指定包以及子包中的类进行加载，而后检测类上是否有Spring框架中指定的注解形容（例如@Component,@Controller,@Service等）。如果有，则将类交给Spring框架中的BeanFactory工厂接口的实现类对象，此工厂对象会基于反射创立Bean的实例，假如此Bean指定了生命周期办法，还会调用生命周期办法。当实例创立当前，Spring框架还会基于类的作用域形容，将实例存储到不同作用域的容器中。以实现Bean对象的迷信利用。业务初步实现及测试常见异样1:NoSuchBeanDefinitionException为什么会有这个异样?先理解一下BeanDefination是什么 Xxx.class是在disk中的而后被一个Thread利用I/O技术,读入到JVM内存中存在BeanDefinition中,存储的就是这个类的配置信息,包,注解等等等等有很多BeanDefinition啊?对的,所以是存储在一个Map中,Map<String,BeanDefinition>,如果没有给@Component("")指定形容,那么String默认为这个bean对应的类名,首字母小写由BeanFactory来创立实例(Bean Instance),存储bean的实例信息,也是存在一个Map中,Map<String,Object>,string的和下面的string一样而NoSuchBeanDefinitionException,这个异样就是没有找到类的配置信息,也就相当于我要一个什么货色,然而连原材料都没有这个异样很常见,其实没有bean的相干的配置,解决办法:1.查看注解是不是丢了常见异样2:No tests found with test runner 'JUNIT5'解决方案:1,查看测试方法是不是private,要求不能用private2,查看单元测试办法是不是void,要求没有返回值3.查看是不是传了参数,要求不能穿参数常见异样3:unable to find SpringBootConfiguration解决方案:1.查看这个测试类是否在启动类的同一个包或子包中,因为SpringBootApplication还包含SpringBootConfiguration 类与类之间的关系有三种关系 is a (实现/继承)has a (有一个属性)use a (调用了一个办法)Eclipse关上查找类窗口快捷键ctrl+shift+T 单例模式,判断两个对象是否是同一个对象?//因为hashcode办法可能算出一样的值,所以如果打印进去值一样,不靠谱System.out.println(p1);System.out.println(p2);//采纳上面这种形式比拟才是真正的比拟对象内存地址System.out.println(p1==p2); 多例模式Scope("prototype")多例对象spring负责创立,不负责销毁spring启动文件会创立单例对象,然而不会创立多例对象

关于springboot:Spring-Boot快速入门之一-简介

【注】本文译自：https://www.tutorialspoint.com/spring_boot/spring_boot_introduction.htm Spring Boot是一个基于Java的开源框架，可用于创立微服务。它由Pivotal团队开发，用来构建可在生产环境独立运行的spring利用。 Spring Boot 蕴含了全面的反对微服务开发的基础设施，并且可能开发可“即时运行”的企业级利用。受众本教程为Java开发者而设计，帮忙他们了解如何以最小化配置开发可用于生产的spring利用。本教程揭示了 Spring Boot 的次要个性，譬如：启动者、主动配置、Bean和 Actuator等。通过本教程，你能够取得中等水平的 Spring Boot技能。先决条件学习本教程须要当时有肯定的Java、Spring、Maven和Gradle的教训。如果你有这些概念，就能够轻松了解Spring Boot的相干概念。要是你领有RESTful Web 服务的编写教训，那会更有劣势。如果你是一位初学者，倡议你在开始学习Spring Boot之前要先对这些方面的常识有所理解。Spring Boot --- 简介本文将带你相熟Spring Boot及其基本概念。什么是微服务？微服务是一个体系结构，容许开发者独立开发和部署服务。每个服务都有其独立的运行过程，并且以轻量机制通信反对业务利用。劣势对于开发者而言，微服务有以下劣势：易于部署便于扩大与容器兼容最小化配置缩短生产工夫什么是Spring Boot?Spring Boot为Java开发者提供了一个优良的平台，可用于开发独立运行的生产级spring利用，并且可能即时运行（just run）。你毋须相熟整个spring配置，只需以最小化的配置进行开发。劣势Spring Boot为开发者提供了以下劣势：易于了解和开发spring利用进步生产效率缩小开发工夫指标Spring Boot的设计指标如下：防止spring简单的XML配置以便捷的形式开发生产级的Spring利用缩小开发和独立运行的工夫提供启动利用的便捷形式为什么要用Spring Boot?之所以要抉择Spring Boot，是因为它可能提供以下个性和利益：提供了灵便的形式来配置Java Beans、XML配置和数据库事务提供了弱小的批处理、治理REST端点在Spring Boot中，所有皆为主动配置，毋须手工配置提供了基于注解的spring利用便捷的依赖治理引入了嵌入式Servlet容器工作原理Spring Boot 应用@EnableAutoConfiguration注解可主动配置利用。 Spring boot 利用的入口点是蕴含@SpringBootApplication 的类和其main办法。 Spring Boot 应用@ComponentScan注解主动扫描我的项目中蕴含的所有组件。 Spring Boot启动器（Starters）对于大型项目而言，依赖治理是一项艰巨的工作。Spring Boot通过为开发者提供一系列便捷的依赖来解决这个难题。比方：要想应用Spring和JPA进行数据库拜访，你只有在我的项目里引入 spring-boot-starter-data-jpa 就能够了。要留神所有的Spring Boot启动器都有雷同的命名范式spring-boot-starter- *，这里 * 批示它是某种的类型类型。示例看看上面解释能够对 Spring Boot 启动器有更好的了解： Spring Boot Starter Actuator dependency 用于监控和治理你的利用。代码如下： ...

关于springboot:SpringBoot

一.我的项目启动过程剖析: SpringBoot我的项目在启动时,首先基于启动入口类上的注解形容,进行主动配置并扫描指定包以及子包中的类进行加载,而后检测类上是否有Spring框架中指定的注解形容,有的话,则将类交给Spring框架中的BeanFactroy工厂接口的实现类对象,此工厂对象会基于反射创立Bean的实例,如果指定了生命周期办法,还会调用生命周期办法,当实例创立了当前,Spring框架还会基于类的作用域形容,将实例存储到不同作用域的容器中.二.Spring框架中的注解: @SpringBootApplication注解形容的类为我的项目的启动入口@Component是Spring中用于形容Bean类的一个注解。@SpringBootTest 注解用于通知spring框架,此测试类交给spring治理。@Autowired注解形容属性时，用于通知spring框架要为此属性注入一个值.@Lazy注解用于形容类,其目标是通知spring框架此类反对提早加载，通常会配合单例作用域应用,默认是true。 @Scope 是Spring中用于定义Bean对象作用域的一个注解,其罕用的值有singleton（整个内存有一份Bean实例,此实例何时创立与类的提早加载个性配置无关，此实例创立当前，生命周期会由spring框架治理）,prototype(每次获取都会创立新实例，此实例会在须要时创立与lazy个性无关，这个实例创立当前，不会交给spring治理，spring能够对其初始化，但不负责销毁。)等。 @PostConstruct 注解用于形容bean对象生命周期办法中的初始化办法，此办法会在对象的构造方法之后执行(是对象创立当前的初始化)。@PreDestroy 注解用于形容Bean对象生命周期办法中的销毁办法，此办法会在对象销毁之前执行（当作用域为prototype时，此办法不会执行）。三.Spring框架治理Bean对象的劣势: Spring框架能够为由它治理的对象(Bean)提供懒加载策略(@Lazy),作用域(@Scope),生命周期办法(@PostConstruct,@PreDestroy),以实现对象对系统的无效应用,同时,Spring框架还能够基于对象和对象之间的依赖关系,升高对象和对象之间的耦合性,进步程序的可维护性和可扩展性.

关于springboot:SpringBoot入门2

创立我的项目一、任何我的项目都得有一个启动入口,在springboot的启动类中，须要应用@SpringBootApplication 注解进行形容，并且在类中会有一个main办法，main办法运行时会读取配置文件，并加载指定资源，而后进行性初始化操作。package cn.wl;import java.util.Arrays;import org.springframework.boot.CommandLineRunner;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;// 启动项@SpringBootApplicationpublic class WlSpringboot1Application implements CommandLineRunner { public static void main(String[] args) { /* mian办法由jvm调用 * args jvm运行时给main办法传值111 222 333 * run（将args中的参数传给了SpringBoot）而后再传递给run（）办法中的 * args * */ SpringApplication.run(WlSpringboot1Application.class, args); System.out.println("WlSpringboot1Application.main()"); System.out.println("main.args=" + Arrays.toString(args)); } /* 在此办法中能够获取Spring容器的一些初始化资源 */ @Override public void run(String... args) throws Exception { System.out.println("run.args=" + Arrays.toString(args)); }} 二、在SpringBoot工程中如何将一个类的实例交给spring创立和治理1.将类放在启动包所在的包或者子类包 2.将类应用spring框架指定注解进行形容，@Component@Component是Spring中用于形容Bean类的一个注解。用于通知Spring这个类的实例由Spring创立，当此对象由Spring创立和治理时，默认会将对象存储到池（Bean池）中。@Componentpublic class DefaultTest {}三、1.Springboot我的项目中配置起源？2.springboot我的项目中的资源加载？（资源能够了解为咱们的class文件）JDK类文件 Spring类文件本人定义的类文件3.SpringBoot中的我的项目资源初始化？a.构建实例对象 b.基于对象存储数据跟踪类加载：-XX:+TranceClassLoading@SpringBootTestpublic class DefaultCacheTests { @Autowired private DefaultCache defaultCache; @Test public void testDefault() { System.out.println(defaultCache); }四、NoSuchBean Spring容器中没有这个Bean ...

关于springboot:Springboot基本的启动

1、我的项目的创立间接在STS中创立spring我的项目所有的配置文件都是创立好我的项目异构由STS工具帮咱们主动创立的如果创立的是一般Maven我的项目则还有一些配置文件须要咱们本人手动创立创立我的项目时呈现网络超时景象：域名解析问题、网络阻塞、所对应服务器线程不够在创立步骤没有问题的前提下所产生的文件报错（pom.xml文件报错）大多是因为所须要的JAR包依赖没有下载下来，其起因或是网速太差，或者所连贯的近程仓库没有所需jar包 2，启动入口任何一个我的项目都有一个启动入口，在springboot中的启动类须要有@SpringBootApplication注解进行形容，并且在类中会定义一个main办法，main办法在运行时会读取配置文件并加载指定资源此注解所标记的类示意通知计算机此为spring的入口类，springboot规定了启动入口内中须要蕴含一个main办法，并且规定其必须放在我的项目中的src/main/java文件夹下。mian办法中主动生成了springboot的入口办法：@SpringBootApplicationpublic class CgbSpringboot02Application { public static void main(String[] args) { SpringApplication.run(CgbSpringboot02Application.class, args); }}3、SpringBoot所罕用到的一些注解1. @SpringBootApplication：用于标记启动入口 2. @SpringBootTest：标记此类为测试类 3. @Component：这个注解是spring中用于形容Bean类的，其实例对象能够由spring自行创立（在spring为此注解标记的类创立实例对象时会将对象搁置在对象池中治理（Bean池），能够在此类上增加其余标签来规定spring为其创建对象的工夫（延时创立“@Lazy”），规定其实例对象的创立形式（@Scope("singleton")@Scope("prototype")） 4. @Lazy：该对象用来通知spring框架该对象不须要事后创立，只在其须要应用时创立实例对象（对内存更敌对） 5. @Scope: @Scope("singleton")：单例作用域--这个类的实例在spring容器中默认只有一份，也就是说该对象实例能够共享，应该留神线程平安问题）该注解在无参数传入时默认是单例模式 @Scope("prototype")：每次从spring容器中获取该对象时都会创立一个对象）6. @PostConstruct：这个注解示意该注解所标记的办法会在对象实例创立之后运行（这里的对象创立基于spring主动创建对象实例）大部分状况下用在@Component所标记的类中的某一个办法，用来对已创立的对象实例进行初始化操作，与其类似的还有@PreDestroy 注解 7. @PreDestroy ：用来标记该办法在单例对象销毁之前执行，spring容器在销毁时会先移除对象池中的实例对象，在移除对象的时候如果对象中定义了生命周期的销毁办法此时还会调用对象的生命周期销毁办法 8. @Autowired：为所创立的对象变量赋值，它是由spring框架所定义、用于对属性或是办法进行形容，在spring框架运行时如果发现其所治理的bean对象中有@Autowired形容的办法或者属性就能够依照既定规定为其赋值，若容器中有且只有一个与所形容办法或属性类型匹配的对象实例就会间接将其注入给@Autowired所形容的办法或属性，假如有多个类型统一的对象就会去匹配其办法名或者属性名，若没有就会抛出异样 9. @Qualifier此注解必须匹配@Atowired应用，用于为@Autowired所形容的办法或属性注入指定类型、指定名字的对象，对其属性和参数进行形容~~~~

关于springboot:Spring-Boot-注解积累

类@Componet:Spring中形容Bean类的一个注解。用于通知Spring框架这个类的实例由Spring创立，默认将对象存储到Bean池中。@SpringBootTest:用于通知spring框架，此测试类交给spring治理。@Lazy:用于形容类，通知spring框架此类反对提早加载，配合单例作用域应用。@Scop：是Spring中用来定义Bean对象作用域的一个注解。 ("singleton"):默认单例作用域，这个类的实例在一个spring容器中默认只有一个值。 ("prototype"):每次获取都会创立新实例，此实例会在须要时创立，这个实例创立当前，不会交给spring治理，spring能够对其初始化，然而不负责销毁。属性@Autowired:形容属性时，用于通知spring框架要为此属性注入一个值。办法@PostConstruct:形容的办法会在对象构建当前执行，用于执行一些初始化操作，用于形容bean对象生命周期办法中的初始化办法。@PreDestroy：办法会在单例对象销毁之前执行，用于形容Bean对象生命周期办法中的销毁办法。

关于springboot:SpringBoot入门第二天

SpringBoot我的项目启动过程剖析首先咱们看一下我的项目启动时产生了什么呢，请看下图： SpringBoot我的项目在启动时，首先基于启动入口类的注解形容，进行主动配置并扫描指定包以及子包中的类进行加载，而后检测类上是否有Spring框架中指定的注解形容（例如@Component,@Controller,@Service等）如果有则将类交给Spring框架中的BeanFactory工厂接口的实现类对象，此工厂对象会基于反射创立bean的实例，退出此Bean指定了生命周期办法，还会调用生命周期办法。当实例创立当前，Spring框架还会基于类作用域形容，将实例存储到不同到作用域容器中，以实现Bean对象的迷信利用。 SpringBoot单元测试报错类型剖析1.可能是单元测试办法被private润饰了2.可能是返回值类型错了，应该是void 无返回值类型3.可能是办法里有参数了，应该是无参数的。