SpringBoot

最新推荐文章于 2023-05-10 18:25:06 发布

正规机构

最新推荐文章于 2023-05-10 18:25:06 发布

阅读量126

点赞数

分类专栏： springboot 文章标签： springboot springboot初始化

本文链接：https://blog.csdn.net/qq_38775188/article/details/92617074

版权

springboot 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

SpringBoot初始化一个应用：
项目中引入springBoot

仅用于个人笔记使用。

SpringBoot初始化一个应用：

网址：https://start.spring.io/

微天气项目micro-weather-basic项目中，idea新建SpringBoot项目，选择web依赖项，在pom.xml中加入依赖项：添加httpclient客户端插件。

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.3</version>
</dependency>

初始化

idea中新建SpringInitializr项目

1.SpringBoot目录用处

resources目录：

static目录用来放js文件

templates目录放如html文件的模板文件

2.项目使用redis

项目名称：micro-weather-redis

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

在服务层service，中使用StringRedisTemplate类（对redis对象进行了包装）调用redis

想要使用上面的依赖项还需要在application.properties文件中添入配置信息

spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=123456
spring.redis.database=0
#spring.redis.pool.max-active=8
#spring.redis.pool.max-wait=-1
#spring.redis.pool.max-idle=500
#spring.redis.pool.min-idle=0
#spring.redis.timeout=0

private void saveCityDataByid(String url,String cityID){
    //从第三方接口获取数据并写入缓存

    String strBody = null;//用来存放responseEntity的strBody部分。
    ValueOperations<String, String> valueOperations = stringRedisTemplate.opsForValue();//对值操作

    ObjectMapper objectMapper = new ObjectMapper();//获取jackson中的对象映射集合
    ResponseEntity<String > responseEntity = restTemplate.getForEntity(url,String.class);

    if(responseEntity.getStatusCodeValue()==200){
        strBody = responseEntity.getBody();

    }
    logger.info("请求"+cityID+"天气数据中,和写入缓存中");
    valueOperations.set(url,strBody,TIME_OUT, TimeUnit.SECONDS);
}

private Weather doGetWeather(String url){
    String key = url;
    Weather weather =null;//用来存放获得的天气对象
    String strBody = null;//用来存放responseEntity的strBody部分。

    ValueOperations<String, String> valueOperations = stringRedisTemplate.opsForValue();//对值操作

    ObjectMapper objectMapper = new ObjectMapper();//获取jackson中的对象映射集合

    if(stringRedisTemplate.hasKey(key)){
    //1.先在缓存中查找数据
       strBody = valueOperations.get(key);
       //添加日志
        logger.info("redis has data");
    }else{
    //2.缓存中没有再去第三方接口查找
        System.out.println("问第三方获取资源");
        ResponseEntity<String > responseEntity = restTemplate.getForEntity(url,String.class);


        //如果返回报的状态码等于200，则获取返回报的身体部分
        if(responseEntity.getStatusCodeValue()==200){
            strBody = responseEntity.getBody();
        }
        logger.info("redis don't has data");
    }
    //3.写入缓存
    valueOperations.set(key,strBody,TIME_OUT, TimeUnit.SECONDS);


    //从map中获取Weather对象
    try {
        if(strBody==null){
            System.out.println("strBody为空");
        }
        weather = objectMapper.readValue(strBody,Weather.class);
    } catch (IOException e) {
        //e.printStackTrace();
        logger.error("Error!",e);
    }
    return weather;
}

house项目使用redis

  @Value("${file.prefix}")
  private String imgPrefix;
  
  /**
   * 1.首先通过缓存获取
   * 2.不存在将从通过数据库获取用户对象
   * 3.将用户对象写入缓存，设置缓存时间5分钟
   * 4.返回对象
   * @param id
   * @return
   */
  public User getUserById(Long id) {
    String key = "user:"+id;
    String json =  redisTemplate.opsForValue().get(key);
    User user = null;
    if (Strings.isNullOrEmpty(json)) {
      user =  userMapper.selectById(id);
      user.setAvatar(imgPrefix + user.getAvatar());
      String string  = JSON.toJSONString(user);
      redisTemplate.opsForValue().set(key, string);
      redisTemplate.expire(key, 5, TimeUnit.MINUTES);
    }else {
      user = JSON.parseObject(json,User.class);
    }
    return user;
  }

3.集成定时器，quartz scheduler,现实定时获取天气数据

在工程micro-weather-client中，无效，使用Spring自带的计时器功能代替

依赖项

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

1.创建job层

创建xxxjob.java文件，该类需要继承QuartzJobBean

package mystudy.microweatherbasic.job;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

//Quartzschdule示例

public class QuartzScheduleJobDemo extends QuartzJobBean {
    //日志
    private static final Logger logger = LoggerFactory.getLogger(QuartzScheduleJobDemo.class);

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        logger.info("do job");
    }
}

2.config层创建配置文件QuartzConfiguration.java

package mystudy.microweatherbasic.config;

import mystudy.microweatherbasic.job.QuartzScheduleJobDemo;
import org.quartz.*;
import org.springframework.context.annotation.Bean;

//定时器配置类，QuartzConfiguration
public class QuartzConfiguration {
    private static final int TIME = 2; // 更新频率,秒
    // JobDetail
    @Bean
    public JobDetail weatherDataSyncJobDetail() {
        return JobBuilder.newJob(QuartzScheduleJobDemo.class).withIdentity("quartzScheduleJobDemo")
                .storeDurably().build();
    }

    // Trigger触发
    @Bean
    public Trigger weatherDataSyncTrigger() {

        SimpleScheduleBuilder schedBuilder = SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(TIME).repeatForever();

        return TriggerBuilder.newTrigger().forJob(weatherDataSyncJobDetail())
                .withIdentity("quartzScheduleDemoSyncTrigger").withSchedule(schedBuilder).build();
    }
}

在工程micro-weather-client中，无效，使用Spring自带的计时器功能代替

SpringScheduleJob.java文件：

package mystudy.microweatherbasic.SpringScheduleTask;

import mystudy.microweatherbasic.city.City;
import mystudy.microweatherbasic.cityService.CityDataService;
import mystudy.microweatherbasic.weatherDataService.GetWeatherDataService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.xml.bind.JAXBException;
import java.io.IOException;
import java.util.List;

//利用Spring自带定时器功能，实现隔半小时同步一次缓存功能
@Component
@Configuration
@EnableScheduling
public class SpringScheduleJob {
    //日志
    private static final Logger logger = LoggerFactory.getLogger(SpringScheduleJob.class);
    @Autowired
    CityDataService cityDataService;
    @Autowired
    GetWeatherDataService getWeatherDataService;

    @Scheduled(fixedRate = 1000*3000)
    public void executeInternal(){
        logger.info("sync start!!");
        //1.获取城市列表,注入CityDataService
        List<City> cityList = null;
        try {
            cityList = cityDataService.getCityList();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (JAXBException e) {
            //e.printStackTrace();
            logger.error("JAXBException",e);
        }
        //2.遍历城市列表,调用天气服务接口，将天气信息写入缓存
        for (City city:cityList
        ) {
            logger.info("sync cityWeatherData");
            if(city.getCityId()!=null){
                getWeatherDataService.syncCityDataById(city.getCityId());
            }

        }

        logger.info("sync end!!");
    }
}

4.(javax中的xml解析)获取城市city.xml数据

很复杂，建议使用xstream见《笔记衣超市笔记.md》，比较简单

映射文件

<?xml version="1.0" encoding="UTF-8"?>
<c c1="0">
<d d1="101280101" d2="广州" d3="guangzhou" d4="广东"/>
<d d1="101280102" d2="番禺" d3="panyu" d4="广东"/>
</c>

City.java

对应cityList.xml文件中的d标签

package mystudy.microweatherbasic.city;
//城市列表中的各城市信息

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name="d")
@XmlAccessorType(XmlAccessType.FIELD)
public class City {

    @XmlAttribute(name="d1")
    private String cityId;

    @XmlAttribute(name="d2")
    private String cityName;

    @XmlAttribute(name="d3")
    private String cityPingyin;

    @XmlAttribute(name="d4")
    private String provinceCenter;

    public void setCityPingyin(String cityPingyin) {
        this.cityPingyin = cityPingyin;
    }

    public String getCityPingyin() {
        return cityPingyin;
    }

    public void setCityId(String cityId) {
        this.cityId = cityId;
    }

    public void setCityName(String cityName) {
        this.cityName = cityName;
    }

    public void setProvinceCenter(String provinceCenter) {
        this.provinceCenter = provinceCenter;
    }

    public String getCityId() {
        return cityId;
    }

    public String getCityName() {
        return cityName;
    }

    public String getProvinceCenter() {
        return provinceCenter;
    }
}

CityList.java

对应整个cityList.xml文件,对应c标签

package mystudy.microweatherbasic.city;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;
import java.util.List;

//城市列表，映射整个xml文件
@XmlRootElement(name="c")
@XmlAccessorType(XmlAccessType.FIELD)
public class CityList {
    @XmlAttribute(name="d")
    private List<City> cityList;

    public void setCityList(List<City> cityList) {
        this.cityList = cityList;
    }
    public List<City> getCityList() {
        return cityList;
    }
}

CityDataServiceImpl文件：

package mystudy.microweatherbasic.cityService.cityServiceImpl;

import mystudy.microweatherbasic.city.City;
import mystudy.microweatherbasic.city.CityList;
import mystudy.microweatherbasic.cityService.CityDataService;
import mystudy.microweatherbasic.util.XmlBuilder;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.stereotype.Service;

import javax.xml.bind.JAXBException;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.List;

@Service
public class CityDataServiceImpl implements CityDataService {
    @Override
    public List<City> getCityList() throws IOException, JAXBException {
        //1.读取xml文件，先将其转换为文本对象

        //Spring中将资源文件转为resource
        Resource resource = new ClassPathResource("static/citylist.xml");
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(resource.getInputStream(),"UTF8"));

        StringBuffer stringBuffer = new StringBuffer();//用来存放读取到的内容
        String str = "";//定义空字符串，在读取高效流时用
        while((str=bufferedReader.readLine())!=null){
            stringBuffer.append(str);
            System.out.println(str);
        }
        //释放资源
        if(bufferedReader!=null){
            bufferedReader.close();
        }
        //2.将文本对象转换为指定对象
        CityList cityList = (CityList) XmlBuilder.xmlStr2Object(CityList.class,stringBuffer.toString());
        return cityList.getCityList();
    }
}

XmlBuilder文件：

package mystudy.microweatherbasic.util;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;

/*
* 工具类
* 将xml文件转为java对象
* */
public class XmlBuilder {
    public static Object xmlStr2Object(Class<?> clazz, String xmlStr) throws JAXBException, IOException {
        Object xmlObject = null;

        //将xml文件以读入字符串流的形式读入
        Reader reader = new StringReader(xmlStr);

        //sun公司的将xml文件转换为java对象。
        // JAXBContext，类中提供了将xml文件转为java对象的接口。
        JAXBContext context = JAXBContext.newInstance(clazz);

        //解析对象,包含转为对象的接口
        Unmarshaller unmarshaller =  context.createUnmarshaller();

        //可以解析多种形式的参数
        xmlObject = unmarshaller.unmarshal(reader);

        //释放资源
        if(reader != null){
            reader.close();
        }
        return xmlObject;
    }
}

在application.properties文件中添加：

spring.thymeleaf.cache=false
//实现springBoot项目热部署静态文件

热部署：

主：https://www.cnblogs.com/winner-0715/p/6666579.html

副：https://www.cnblogs.com/a8457013/p/8065489.html

maven依赖项：

<!--使用springboot的热部署-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

1.开启idea自动make功能

Settings --> 查找make project automatically --》选中

2.设置：

Ctrl+Shift+alt+/快捷键，设置Registry，勾选compiler.automake.allow.when.app.running

3.重启idea

4.配置依赖项

在ssm框架中使用无效

bootstrap（缺）

前端设计，thymeleaf

thymeleaf面向后端的数据渲染引擎

项目中引入springBoot

方式1：pom继承spring-boot-starter-parent

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

方式2：pom引入spring-boot-dependencies

。。。
    <dependencyManagement>
		<dependencies>
            <dependency>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-dependencies</artifactId>
				<version>1.4.7.RELEASE</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		
		</dependencies>
	</dependencyManagement>
。。。