Springboot+redis+freemarker 自定义注解实现页面缓存

最新推荐文章于 2023-10-25 21:06:19 发布
最新推荐文章于 2023-10-25 21:06:19 发布
阅读量667 收藏 1
点赞数
文章标签： redis freemarker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40341527/article/details/108399144
版权

pom.xml 

 

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

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

        <dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>1.10.2</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.61</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

        <!--redis-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

        <!--自定义注解-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</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.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <dependencies>
                    <!-- spring热部署 -->
                    <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>springloaded</artifactId>
                        <version>1.2.6.RELEASE</version>
                    </dependency>
                </dependencies>
                <configuration><fork>true</fork></configuration>
            </plugin>
        </plugins>
    </build>

 

application.properties

 

server.port=1234
server.servlet.context-path=/redis_freemarker

# 开启热部署
spring.devtools.restart.enabled=true

spring.mvc.view.suffix=.ftl
spring.mvc.static-path-pattern: /**

#    freemarker静态资源配置
#       设定ftl文件路径
spring.freemarker.tempalte-loader-path=classpath:/templates
#        关闭缓存，及时刷新，上线生产环境需要修改为true
spring.freemarker.cache=false
spring.freemarker.charset=UTF-8
spring.freemarker.check-template-location=true
spring.freemarker.content-type=text/html
spring.freemarker.expose-request-attributes=true
spring.freemarker.expose-session-attributes=true
spring.freemarker.request-context-attribute=request
spring.freemarker.suffix=.ftl
# 空值不报错
spring.freemarker.settings.classic_compatible=true

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.timeout=3
spring.redis.password=123456
spring.redis.jedis.pool.max-wait=3
spring.redis.jedis.pool.max-idle=10
spring.redis.jedis.pool.max-total=10

 

redis 注册类  

RedisConfig
package com.example.redis_freemarker;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;


@Component
@PropertySource(value = {"classpath:application.properties"})
public class RedisConfig {

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;//秒
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.jedis.pool.max-total}")
    private int poolMaxTotal;
    @Value("${spring.redis.jedis.pool.max-idle}")
    private int poolMaxIdle;
    @Value("${spring.redis.jedis.pool.max-wait}")
    private int poolMaxWait;//秒

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getPoolMaxTotal() {
        return poolMaxTotal;
    }

    public void setPoolMaxTotal(int poolMaxTotal) {
        this.poolMaxTotal = poolMaxTotal;
    }

    public int getPoolMaxIdle() {
        return poolMaxIdle;
    }

    public void setPoolMaxIdle(int poolMaxIdle) {
        this.poolMaxIdle = poolMaxIdle;
    }

    public int getPoolMaxWait() {
        return poolMaxWait;
    }

    public void setPoolMaxWait(int poolMaxWait) {
        this.poolMaxWait = poolMaxWait;
    }

    @Bean
    public JedisPool jedisPoolFactory() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(poolMaxIdle);
        jedisPoolConfig.setMaxTotal(poolMaxTotal);
        jedisPoolConfig.setMaxWaitMillis(poolMaxWait * 1000);
        JedisPool jedisPool = new JedisPool(jedisPoolConfig,
                host,
                port,
                timeout * 1000,
                password);
        return jedisPool;
    }
}

 

redis 工具类 

RedisService
package com.example.redis_freemarker;

import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

@Service
public class RedisService {

    @Autowired
    private JedisPool jedisPool;

    /**
     * 获取存储对象
     * @param key
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> T get(String key, Class<T> clazz) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String str = jedis.get(key);
            T t = stringToBean(str, clazz);
            return t;
        } finally {
            returnToPool(jedis);
        }
    }

    /**
     * 设置对象
     * @param key
     * @param expireSeconds
     * @param value
     * @param <T>
     * @return
     */
    public <T> boolean set(String key, int expireSeconds, T value) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String str = beanToString(value);
            if (null == str) {
                return false;
            }
            if (expireSeconds <= 0) {
                jedis.set(key, str);
            } else {
                jedis.setex(key, expireSeconds, str);
            }
            return true;
        } finally {
            returnToPool(jedis);
        }
    }

    /**
     * 判断key是否存在
     * */
    public <T> boolean exists(String key) {
        Jedis jedis = null;
        try {
            jedis =  jedisPool.getResource();
            return  jedis.exists(key);
        }finally {
            returnToPool(jedis);
        }
    }

    /**
     * 增加值
     * */
    public <T> Long incr(String key) {
        Jedis jedis = null;
        try {
            jedis =  jedisPool.getResource();
            return  jedis.incr(key);
        }finally {
            returnToPool(jedis);
        }
    }

    /**
     * 减少值
     * */
    public <T> Long decr(String key) {
        Jedis jedis = null;
        try {
            jedis =  jedisPool.getResource();
            return  jedis.decr(key);
        }finally {
            returnToPool(jedis);
        }
    }

    private <T> String beanToString(T value) {
        if (null == value) {
            return null;
        }
        if (value instanceof Integer || value instanceof Long) {
            return "" + value;
        } else if (value instanceof String) {
            return (String) value;
        } else {
            return JSON.toJSONString(value);
        }
    }

    private <T> T stringToBean(String str, Class<T> clazz) {
        if (StringUtils.isEmpty(str) || clazz==null) {
            return null;
        }
        if (clazz==int.class || clazz==Integer.class) {
            return (T) Integer.valueOf(str);
        } else if (clazz == String.class) {
            return (T) str;
        } else if (clazz==long.class || clazz==Long.class) {
            return (T)Long.valueOf(str);
        } else {
            return JSON.toJavaObject(JSON.parseObject(str), clazz);
        }
    }

    private void returnToPool(Jedis jedis) {
        if (null != jedis) {
            jedis.close();
        }
    }
}

 

freemaker 工具类

import freemarker.template.Configuration;
import freemarker.template.Template;
import freemarker.template.TemplateException;
import freemarker.template.TemplateExceptionHandler;

import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.util.Map;

public class FreemarkerUtils {
    public static String getTemplate(String template, Map<String,Object> map) throws IOException, TemplateException {
        Configuration cfg = new Configuration(Configuration.VERSION_2_3_28);
        String templatePath = FreemarkerUtils.class.getResource("/").getPath()+"/templates";
        cfg.setDirectoryForTemplateLoading(new File(templatePath));
        cfg.setDefaultEncoding("UTF-8");
        cfg.setTemplateExceptionHandler(TemplateExceptionHandler.RETHROW_HANDLER);
        cfg.setLogTemplateExceptions(false);
        cfg.setWrapUncheckedExceptions(true);
        cfg.setClassicCompatible(true);// 空值不报错
        Template temp = cfg.getTemplate(template);
        StringWriter stringWriter = new StringWriter();
        temp.process(map, stringWriter);
        return stringWriter.toString();
    }
}

 

新建一个自定义注解   AutoRedis 

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface AutoRedis {

    String key(); // redis key 值

    String returnFtl();  // 返回的ftl页面路径

    int expireSeconds() default 86400; // 缓存过期时间,默认24小时

    boolean soutIfTrue() default true;  // 是否打印信息

}

 

新建一个 AOP 

RedisAspect
package com.example.redis_freemarker;

import com.alibaba.fastjson.JSON;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

import java.lang.reflect.Method;
import java.util.Map;



@Aspect
@Configuration
public class RedisAspect {

    @Autowired
    private RedisService redisService;

    //定义切点方法
    @Pointcut("@annotation(com.example.redis_freemarker.AutoRedis)")
    public void pointCut(){}

    //环绕通知
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable,Exception {

        //1.获取到所有的参数值的数组
        Object[] args = joinPoint.getArgs();
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        //2.获取到方法的所有参数名称的字符串数组
        String[] parameterNames = methodSignature.getParameterNames();
        Method method = methodSignature.getMethod();
        Class<?> returnType = method.getReturnType(); // 返回类型
        Class<?> classTarget = joinPoint.getTarget().getClass();

        AutoRedis redis=(AutoRedis)method.getAnnotation(AutoRedis.class);
        boolean soutIfTrue=redis.soutIfTrue();
        soutIfTrue(soutIfTrue,"■■■■■■■■■■■■■■■■■■■■■-AutoRedis注解开始-■■■■■■■■■■■■■■■■■■■■■");
        String key=redis.key();
        String returnFtl=redis.returnFtl();
        int expireSeconds=redis.expireSeconds();
        soutIfTrue(soutIfTrue,"自定义注解 key:" + key);
        soutIfTrue(soutIfTrue,"自定义注解 returnFtl:" + returnFtl);
        soutIfTrue(soutIfTrue,"自定义注解 expireSeconds:" + expireSeconds);
        soutIfTrue(soutIfTrue,"---------------参数列表开始-------------------------");
        for (int i =0 ,len=parameterNames.length;i < len ;i++){
            soutIfTrue(soutIfTrue,"参数名："+ parameterNames[i] + " = " +args[i]);
            key=redis.key().replaceAll("【"+parameterNames[i]+"】",args[i].toString());
        }
        soutIfTrue(soutIfTrue,"---------------参数列表结束-------------------------");
        soutIfTrue(soutIfTrue,"自定义注解解析后 key:" + key);

        // String html = redisService.get(key, String.class);
        Map<String,Object> map = redisService.get(key, Map.class);

        /*
         1.这里有两种方式存储，可以存储整个HTML代码放进redis,这种数据库压力较大
         2.也可以把 Object result 放进redis,这样redis库不会浪费空间，然后读缓存的时候用freemarker 转换一下,这种服务器压力较大。
        */

        // 1.
        /*
        if (!StringUtils.isEmpty(html)) {
            soutIfTrue(soutIfTrue,"有缓存，返回缓存数据");
            soutIfTrue(soutIfTrue,"■■■■■■■■■■■■■■■■■■■■■-AutoRedis注解结束-■■■■■■■■■■■■■■■■■■■■■\n\n\n");
            return html;
        }else{
            Object result=joinPoint.proceed(args);
            String cmtTpl= null;
            cmtTpl = FreemarkerUtils.getTemplate(returnFtl, (Map<String,Object>)JSON.parseObject(result.toString()));
            // 存入缓存
            if(!StringUtils.isEmpty(cmtTpl)){
                soutIfTrue(soutIfTrue,"没有缓存，返回刚查询的数据，并且存入redis");

                redisService.set(key, expireSeconds, cmtTpl);
            }
            soutIfTrue(soutIfTrue,"■■■■■■■■■■■■■■■■■■■■■-AutoRedis注解结束-■■■■■■■■■■■■■■■■■■■■■\n\n\n");
            return cmtTpl;
        }
        */

        // 2.
        if (map!=null) {
            soutIfTrue(soutIfTrue,"有缓存，返回缓存数据");
            String cmtTpl= null;
            cmtTpl = FreemarkerUtils.getTemplate(returnFtl,map);
            soutIfTrue(soutIfTrue,"■■■■■■■■■■■■■■■■■■■■■-AutoRedis注解结束-■■■■■■■■■■■■■■■■■■■■■\n\n\n");
            return cmtTpl;
        }else{
            Object result=joinPoint.proceed(args);
            String cmtTpl= null;
            cmtTpl = FreemarkerUtils.getTemplate(returnFtl, (Map<String,Object>)JSON.parseObject(result.toString()));
            // 存入缓存
            if(!StringUtils.isEmpty(cmtTpl)){
                soutIfTrue(soutIfTrue,"没有缓存，返回刚查询的数据，并且存入redis");
                redisService.set(key, expireSeconds, (Map)JSON.parseObject(result.toString()));
            }
            soutIfTrue(soutIfTrue,"■■■■■■■■■■■■■■■■■■■■■-AutoRedis注解结束-■■■■■■■■■■■■■■■■■■■■■\n\n\n");
            return cmtTpl;
        }

    }

    public void soutIfTrue(Boolean flag,String str){
        if(flag){
            System.out.println(str);
        }
    }

}

 

最后来实验一下

package com.example.redis_freemarker;

import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.Map;


@Controller
public class test {

    @Autowired
    private RedisService redisService;

    @RequestMapping(value = "/test")
    @ResponseBody
    public String test(String page) {

        if(StringUtils.isEmpty(page)){
            return "page参数不能为空";
        }

        //判断redis是否有缓存
        String html = redisService.get(page, String.class);
        if (!StringUtils.isEmpty(html)) {
            System.out.println("有缓存，返回缓存数据");
            //System.out.println(html);
            return html;
        }

        // 这里模拟一下查询数据，浪费时间3秒
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Map<String,Object> map=new HashMap<>();
        map.put("NAME","吴彦祖");
        map.put("ID","14567");
        map.put("AGE","18");
        map.put("PAGE",page);


        String cmtTpl= null;
        try {
            cmtTpl = FreemarkerUtils.getTemplate("/test/test.ftl",map);
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 存入缓存
        if(!StringUtils.isEmpty(cmtTpl)){
            System.out.println("没有缓存，返回刚查询的数据，并且存入redis");
            redisService.set(page, 86400, cmtTpl);
        }

        return cmtTpl;
    }


    @RequestMapping("/test2")
    @ResponseBody
    @AutoRedis(key = "HELLO_【page】",returnFtl = "/test/test.ftl",expireSeconds = 86400,soutIfTrue = true)
    public String test2(String page){
        if(StringUtils.isEmpty(page)){
            return "page参数不能为空";
        }
        // 这里模拟一下查询数据，浪费时间3秒
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Map<String,Object> map=new HashMap<>();
        map.put("NAME","吴彦祖");
        map.put("ID","14567");
        map.put("AGE","18");
        map.put("PAGE",page);

        return JSON.toJSONString(map);
    }
}

 

 

 

test.ftl

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
</head>
<body>
<table border="1">
    <thead>
    <tr>
        <th>PAGE</th>
        <th>NAME</th>
        <th>ID</th>
        <th>AGE</th>
    </tr>
    </thead>
    <tbody>
    <tr>
        <td>${PAGE}</td>
        <td>${NAME}</td>
        <td>${ID}</td>
        <td>${AGE}</td>
    </tr>
    </tbody>
</table>
</body>
</html>

 

 

懒得起名字的小白
关注
如何在项目里面使用freemarker实现页面缓存（三）
IT程序员的成长记
10-20 6512
1.环境配置:在这里我就不说了，上面两篇有如何配置freemarker 2.在项目里面你运用freemarker需要在项目里面创建一个模板文件夹，在web-inf下面创建一个ftl文件夹 3.由于通过freemarker将模板页面转化为html页面，前台访问直接跳页面就行了，所以不能把生成的html文件放入web-inf文件夹下面，在webapp下创建一个文件夹命名html 4.写servi
SpringBoot+Redis简单应用开发
qq_37951410的博客
08-19 154
1.Redis简单介绍 什么是Redis？ Redis是一种NoSQL技术，基于键值对的开源的内存数据存储。 支持五种数据类型的： 属性 描述 string 字符串 hash 散列 list 列表 set 集合 zset 有序集合 Spring Data Redis 提供两个模板(RedisTemplate、StringRedisTemplate)： Re...
springmvc + freemarker 开发环境 缓存设置
z69183787的专栏
01-20 3207
通过阅读源码搞定了 先设置springmvc的缓存控制。这是最高优先级的缓存控制。一旦springmvc发现没有缓存开启，就会进行cache，如果发现缓存没开启，则会每次生成一个view（通过调用freemarker的方法来进行）。再设置freemakre的缓存控制。freemakre通过一个时间长度来控制缓存在上面两步完成之后，一般来说就可以了。但是还有一个问题是，web访问的是targe
【Freemarker】SpringMVC&Freemarker视图渲染的两级缓存
beFocused的博客
03-14 641
开发springmvc+freemarker项目时经常调试页面模版元素。想让修改立即生效，就关闭缓存，否则视图渲染一直走缓存。关闭缓存就要注意了，需要关闭两处缓存。第一级缓存，FreeMarkerViewResolver的视图缓存(viewAccessCache)，设置cacheLimit=0则关闭。 第二级缓存，模版缓存(TemplateCache)，设置template_update_delay=0则关闭。
解决freemarker缓存问题
weixin_43526092的博客
03-30 3368
问题：项目中使用的freemarker模板，每次修改 .ftl 或 .js 文件后，需要重启项目后才能看到修改后的变化。 解决方案： 在application.properties配置文件中加入以下属性： spring.freemarker.settings.template_update_delay=0 ...
【FreeMarker】【程序开发】模板加载，模板缓存
王晓斌的专栏
10-26 8485
模板加载器 模板jia'zai
springboot+redis+mybatis事务和引擎模板
09-27
在本项目中，“springboot+redis+mybatis事务和引擎模板”是一个综合性的Spring Boot应用，它整合了MyBatis和Redis技术，用于实现高效的数据处理和缓存管理。下面将详细阐述其中涉及的关键知识点： 1. **Spring ...
基于SpringBoot + MyBatis + Redis的图像素材管理系统.zip
09-11
Redis是一个高性能的键值对数据库，通常用于缓存数据和实现分布式服务。在这个系统中，Redis可能被用来存储用户访问频繁的图像素材，以提高读取速度。Redis支持多种数据结构如字符串、哈希、列表、集合、有序集合，...
Springboot redis缓存
最新发布
weixin_68193389的博客
10-25 282
在支持Spring Cache的环境下，对于使用@Cacheable标注的方法，Spring在每次执行前都会检查Cache中是否存在相同key的缓存元素，如果存在就不再执行该方法，而是直接从缓存中获取结果进行返回，否则才会执行并将返回结果存入指定的缓存中。在存储快照后，还可以让redis来进行数据校验，如果数据已经损坏就不需要再进行持久化的操作，这样做会增加大约10%的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能,推荐yes.使用新的AOF文件覆盖旧的AOF文件，完成AOF重写。
redis项目中的实际应用_freemarker在实际项目中的应用场景
weixin_32721919的博客
01-20 167
昨天简单介绍了网页静态化技术freemarker，但由于个人原因并未展示静态化技术在项目中的应用场景，今天就闲言少叙，开始正文。以DR钻戒为例，当我们看到商品详情页面后。在点击红色区域选择商品规格时，传统做法仍需要访问数据库，因为每点击一次其他的规格就需要访问一次服务器。这种结构固定的场景就非常适合静态化技术，如果提前把这些需要频繁交互的数据，以json字...
springBoot整合freemarker
culous的博客
04-12 277
渲染Web页面 在之前的示例中，我们都是通过@RestController来处理请求，所以返回的内容为json对象。那么如果需.要渲染html页面的时候，要如何实现呢? 模版引擎目的 动态页面伪装静态化提高搜索引擎收录 管理平台才会使用jsp 模板引擎 在动态HTML实现上Spring Boot依然可以完美胜任，并且提供了多种模板引擎的默认配置支持，所以在推荐的模板引擎下，我们可以很快的上手开发...
Freemarker源码分析（3）cache.CacheStorage及其子类
Vakie的博客
10-24 483
2021SC@SDUSC Freemarker源码分析（3）cache.CacheStorage及其子类cache.CacheStorage及其子类1.CacheStorage接口2.CacheStorageWithGetSize接口3.ConcurrentCacheStorage接口4.NullCacheStorage类5.SoftCacheStorage类6.StrongCacheStorage类7.MruCacheStorage类 cache.CacheStorage及其子类 总览图 1.Cache
SpringBoot添加freemarker模板引擎
热门推荐
bossaiaboy的专栏
05-24 1万+
1、pom.xml添加依赖： org.springframework.boot spring-boot-starter-freemarker 2、配置freemarker的javaConfig package com.im.adplayer.config; import javax.annotation.PostConstruct; import org.springframew
Springboot整合模板引擎之freemarker(七)
wzcwmhp的博客
05-19 1917
freemarker
spring boot 2.0完美整合mybatis注解版 加上redis储存数据 配上freemarker模板 实现用户的登录注册
qq_43650896的博客
12-13 275
spring boot 2.0完美整合mybatis注解版 加上redis储存数据 配上freemarker模板 实现用户的登录注册 首先导入pom文件 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w...
FreeMarker使用小结
Shang的专栏
04-08 1101
FreeMarker使用小结1. FreeMarker模板引擎的使用: 模板 + 数据模型 = 输出1) FreeMarker模板：一个普通文本文件，其中使用了一些FreeMarker的特别标记。2) 数据模型：存放了数据的数据结构，通常是一个Hash存储结构(如:HashMap)3) FreeMarker框架负责将一个数据模型中的数据合并到模板中，从而生成输出。2. 配置使用环境: 下载
FreeMarker详细介绍
qq_43751200的博客
03-29 1385
记录FreeMarker的简介、入门实战以及FreeMarker在项目中的实际应用。
SpringBoot整合druid、mybatis、pagehelper、freemarker、redis
qq_53002141的博客
01-18 886
SpringBoot整合druid、mybatis、pagehelper、freemarker、redis
SpringBoot整合FreeMarker
白豆五的博客
05-04 1870
FreeMarker被设计用来生成HTML Web页面，特别是基于MVC模式的应用程序，将视图从业务逻辑中抽离出来，业务中不再包括视图的展示，而是将视图交给FreeMarker来输出。虽然FreeMarker具有一些编程的能力，但通常先让Java程序准备要显示的数据，然后再用FreeMarker生成具体页面。FreeMarker 也是一款模板引擎技术，它是一种基于模板和要改变的数据，并用来生成输出文本(HTML网页，电子邮件，配置文件，源代码等)的通用工具。
SpringBoot框架详解与实战指南
4. **全局异常处理**：SpringBoot可以通过自定义`@ControllerAdvice`注解的类来实现全局异常处理，这样可以统一处理所有控制器可能出现的异常。 5. **YAML和Properties详解**：SpringBoot支持使用YAML或Properties...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值