精华内容
下载资源
问答
  • 本案例是一个通过静态代码块获取资源属性文件的代码块,从而来提高应用性能。。
  • Java类获取配置文件中的静态常量

    千次阅读 2020-10-28 16:12:42
    Java类获取配置文件中的静态常量通过注解方式获取常量值@Value注解进行配置文件信息的获取@ConfigurationProperties注解获取配置文件 通过注解方式获取常量值 当我们在编写代码过程中,部分常量信息可能需要多处公用...

    通过注解方式获取常量值

    当我们在编写代码过程中,部分常量信息可能需要多处公用,通常会把这些常量写进xml配置文件中,通过相关配置信息在代码中使用。如下dingding:的相关常量的值;
    在这里插入图片描述

    @Value注解进行配置文件信息的获取

    新建一个常量获取类DingDingConstant,声明各种常量,并写入set方法,在set方法上使用@Value注解获取配置文件中的值,并赋值给相应的对象,括号中通过 @Value("${dingding.agentId}") 可指定读取配置文件中的对象。

    package com.mallplus.common.constant;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    /**
     * @author: SUN
     * @version: 1.0
     * @date: 2020/10/9 19:33
     * @description: 项目中的常量定义类
     */
    @Component
    public class DingDingConstant {
        /**
         * 企业应用标识(ISV调用必须设置)
         */
        public static Long AgentId;
    
        /**
         *
         */
        public static String AppKey;
    
        /**
         *
         */
        public static String AppSecret;
    
        /**
         * 企业corpid, 需要修改成开发者所在企业
         */
        public static String CorpId;
    
        /**
         * 加解密需要用到的token,ISV(服务提供商)推荐使用注册套件时填写的token,普通企业可以随机填写
         */
        public static String Token;
    
        /**
         * 数据加密密钥。用于回调数据的加密,长度固定为43个字符,从a-z, A-Z, 0-9共62个字符中选取,
         * 您可以随机生成,ISV(服务提供商)推荐使用注册套件时填写的EncodingAESKey
         */
        public static String AesKey;
    
        /**
         * 接收事件回调的url,必须是公网可以访问的url地址
         */
        public static String Url;  // 本地测试回调地址
    
        /**
         * 审批表单中详情拼接URL地址
         */
        public static String DetailUrl;
    
    
        @Value("${dingding.agentId}")
        public void setAgentId(Long agentId) {
            AgentId = agentId;
            System.out.println("- - - agentId-   " + agentId);
        }
    
        @Value("${dingding.appKey}")
        public void setAppKey(String appKey) {
            AppKey = appKey;
            System.out.println("- - - appKey-   " + appKey);
        }
    
        @Value("${dingding.appSecret}")
        public void setAppSecret(String appSecret) {
            AppSecret = appSecret;
            System.out.println("- - - appSecret-   " + appSecret);
        }
    
        @Value("${dingding.corpId}")
        public void setCorpId(String corpId) {
            CorpId = corpId;
            System.out.println("- - - corpId-   " + corpId);
        }
    
        @Value("${dingding.token}")
        public void setToken(String token) {
            Token = token;
            System.out.println("- - - token-   " + token);
        }
    
        @Value("${dingding.aesKey}")
        public void setAesKey(String aesKey) {
            AesKey = aesKey;
            System.out.println("- - - aesKey-   " + aesKey);
        }
    
        @Value("${dingding.url}")
        public void setUrl(String url) {
            Url = url;
            System.out.println("- - - url-   " + url);
        }
    
        @Value("${dingding.detailUrl}")
        public void setDetailUrl(String detailUrl) {
            DetailUrl = detailUrl;
            System.out.println("- - - detailUrl-   " + detailUrl);
        }
    
    }
    
    

    @ConfigurationProperties注解获取配置文件

    @ConfigurationProperties 相比**@Value** 注解进行配置文件信息的读取配置起来较为简单;只需在类名上添加注解,并指定对应的配置信息即可,并添加get() set() 方法;

    package com.mallplus.common.utils;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.net.HttpURLConnection;
    import java.net.MalformedURLException;
    import java.net.URL;
    import java.net.UnknownHostException;
    import java.util.List;
    import java.util.Map;
    
    /**
     * @author: SUN
     * @version: 1.0
     * @date: 2020/10/28 9:44
     * @description:
     */
    @ConfigurationProperties(prefix = "dingding")
    @Component
    public class AliyunLinkUtils {
    
    // public 即可外部引用,通过类名直接引用,如:AliyunLinkUtils.agentId;
    // 若设置为 private 即只能在此类内部使用;
        public static String agentId;
        public static String appKey;
        public static String appSecret;
    
        public String getAgentId() {
            return agentId;
        }
    
        public void setAgentId(String agentId) {
            System.out.println("-- agentId- -1 - " + agentId);
            this.agentId = agentId;
        }
    
        public String getAppKey() {
            return appKey;
        }
    
        public void setAppKey(String appKey) {
            this.appKey = appKey;
        }
    
        public String getAppSecret() {
            return appSecret;
        }
    
        public void setAppSecret(String appSecret) {
            this.appSecret = appSecret;
        }
    }
    
    
    展开全文
  • Java获取静态资源文件路径

    千次阅读 2021-01-20 17:02:40
    Java获取静态资源文件路径 ​ 开发中经常会有文件相关的操作,比如说文件的查找,文件的存储。但是在使用中往往会因为路径问题耽误大量的开发时间。在实际中常常通过File file = new File(“c://a.txt”)方式来使用...

    Java获取静态资源文件路径

    ​ 开发中经常会有文件相关的操作,比如说文件的查找,文件的存储。但是在使用中往往会因为路径问题耽误大量的开发时间。在实际中常常通过File file = new File(“c://a.txt”)方式来使用,但是切换环境后可能会遇到找不到该资源的问题。Java中,可以使用getResource()方法来获取资源。

    项目工程如下:

    在这里插入图片描述

    1.Class和ClassLoader对于getResouce()的区别?

    public class ResourceTest {
    
        @Test
        public void test1() {
            // /Users/luojiacheng/code/translaction-test/target/test-classes/com/ljc/
            System.out.println(ResourceTest.class.getResource("").getPath());
            // /Users/luojiacheng/code/translaction-test/target/test-classes/
            System.out.println(ResourceTest.class.getResource("/").getPath());
    
            // /Users/luojiacheng/code/translaction-test/target/test-classes/
            System.out.println(ResourceTest.class.getClassLoader().getResource("").getPath());
            // null
            System.out.println(ResourceTest.class.getClassLoader().getResource("/"));
        }
    
    
    }
    

    Class:

    getResource("")获取的是当前文件的路径;

    getResouce("/")获取的是classes下的路径,在spring中相当于/WEB-INF/classes/下;

    ClassLoader:

    getResource("")获取的是classes下的路径,等同于Class.getResource("/");

    getResouce("/")无法获取。

    2.getResourceAsStream()

    public InputStream getResourceAsStream(String name) {
        URL url = getResource(name);
        try {
            return url != null ? url.openStream() : null;
        } catch (IOException e) {
            return null;
        }
    }
    

    getResourceAsStream()其实就是在getReource() + new InputStream()。

    3.Class.getResource()实现

    public java.net.URL getResource(String name) {
        // 获取包路径
        name = resolveName(name);
        ClassLoader cl = getClassLoader0();
        if (cl==null) {
            // A system class.
            return ClassLoader.getSystemResource(name);
        }
      	// "" -> com/.../    "/" -> ""
        return cl.getResource(name);
    }
    

    Class的getResouce方法实际调用就是ClassLoader的getResource方法,只不过在调用前对文件名进行了额外的处理,将“”转为了包路径,“/”转为了“”。

    4.示例

    
        /**
         * 无内容返回
         */
        @GetMapping("/getTextFromFile")
        public String getTextFromFile() throws IOException {
            String filePath = MyFileOperation.class.getResource("/a.txt").getPath();
            // **.jar!/BOOT-INF/classes!/a.txt
            System.out.println(filePath);
            File file = new File(filePath);
            StringBuilder s = new StringBuilder();
            if (file.exists()) {
                InputStreamReader isr = new InputStreamReader(new FileInputStream(file), "gbk");
                BufferedReader bufferedReader = new BufferedReader(isr);
                String str;
                while ((str = bufferedReader.readLine()) != null) {
                    s.append(str);
                }
            }
            return s.toString();
        }
        
        
        /**
         * 正确
         */
        @GetMapping("/getTextFromFileByStream")
        public String getTextFromFileByStream() throws IOException {
            StringBuilder s = new StringBuilder();
            InputStreamReader isr = new InputStreamReader( MyFileOperation.class.getResourceAsStream("/a.txt"), "gbk");
            BufferedReader bufferedReader = new BufferedReader(isr);
            String str;
            while ((str = bufferedReader.readLine()) != null) {
                s.append(str);
            }
            return s.toString();
        }
    
    展开全文
  • java 获取resource下的静态资源文件

    千次阅读 2020-06-19 11:10:05
    (2)、实现逻辑:先获取静态资源的url路径,方法两种,但各有些小问题 第一种: import java.net.URL; import org.springframework.core.io.ClassPathResource; URL url = new ClassPathResource("excelTmp/stu.

    1、后台下载文件比较简单的逻辑步骤

    (1)、准备静态模板文件:把静态资源文件放到src/main/resource路径下,如:excelTmp/studentDemo.xlsx

    (2)、实现逻辑:先获取静态资源的url路径,方法两种,但各有些小问题

      第一种:

    import java.net.URL; import org.springframework.core.io.ClassPathResource;
    URL url = new ClassPathResource("excelTmp/studentDemo.xlsx").getURL();

    这种方法在参数的路径上,不能包含中文(实现功能可以,推荐使用)

    第二种:

    URL url = getClass().getClassLoader().getResource("excelTmp/学生模板.xlsx");

    这种方法在本地tomcat运行可以准确的获取静态资源文件,但亲测在linux服务器上获取的url为null(本人的测试的项目,调用处被打包在lib下的jar包中,对于存在一些特殊情况下会出问题,因此,不推荐使用)

    (3)、获取资源后见的url后,获取文件,转文件的字节数组,通过respone的输出流,将文件字节数组输出

    (4)、前端通过a标签,将href指定为接口地址,即可实现下载文件的效果(所以要求可以get请求)

    (5)、调用实现详细代码如下

    import com.hx.platform.annotation.BusiAnnotation;
    import com.hx.platform.education168.ptgl.common.util.FileUtil;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.File;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.URL;
    import java.net.URLEncoder;
    
    
    @RestController
    @RequestMapping("/eduStudent")
    @BusiAnnotation(busiModule = "学生管理")
    public class StudentController {
    
    	// 日志
    	private static Logger logger = LoggerFactory.getLogger(StudentController.class);
    
    	@RequestMapping("/downloadExcel11")
    	public void testStream11(String excelType, HttpServletRequest req, HttpServletResponse resp) {
    		try {
    			URL url = null;
    			if("1".equals(excelType)){
    				url = getClass().getClassLoader().getResource("excelTmp/学生模板.xlsx");
    			} else if("2".equals(excelType)) {
    				url = getClass().getClassLoader().getResource("excelTmp/家长模板.xlsx");
    			} else if("3".equals(excelType)) {
    				url = getClass().getClassLoader().getResource("excelTmp/教师模板.xlsx");
    			}
    			logger.info("url:" + url);
    			// 通过url获取File的绝对路径
    			File f = new File(url.getFile());
    			resp.setCharacterEncoding("UTF-8");
    			resp.setContentType("application/x-download;charset=utf-8");
    			resp.setHeader("Content-disposition",  URLEncoder.encode(f.getName(), "UTF-8"));
    			//mime类型
    			resp.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
    			resp.setHeader("Content-disposition", "attachment;filename="+URLEncoder.encode(f.getName(), "UTF-8"));
    			resp.setHeader("Pragma", "No-cache");
    			//从内存中写出来
    			OutputStream outputStream = resp.getOutputStream();
    			outputStream.write(FileUtil.file2byte(f));
    			outputStream.close();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    
    	}
    
    	@RequestMapping("/downloadExcel")
    	public void testStream(String excelType, HttpServletRequest req, HttpServletResponse resp) {
    		try {
    			URL url = null;
    			if("1".equals(excelType)){
    				url = new ClassPathResource("excelTmp/studentDemo.xlsx").getURL();
    			} else if("2".equals(excelType)) {
    				url = new ClassPathResource("excelTmp/parentDemo.xlsx").getURL();
    			} else if("3".equals(excelType)) {
    				url = new ClassPathResource("excelTmp/teacherDemo.xlsx").getURL();
    			}
    			logger.info("url:" + url);
    			// 通过url获取File的绝对路径
    			File f = new File(url.getFile());
    			resp.setCharacterEncoding("UTF-8");
    			resp.setContentType("application/x-download;charset=utf-8");
    			resp.setHeader("Content-disposition",  URLEncoder.encode(f.getName(), "UTF-8"));
    			//mime类型
    			resp.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
    			resp.setHeader("Content-disposition", "attachment;filename="+URLEncoder.encode(f.getName(), "UTF-8"));
    			resp.setHeader("Pragma", "No-cache");
    			//从内存中写出来
    			OutputStream outputStream = resp.getOutputStream();
    			outputStream.write(FileUtil.file2byte(f));
    			outputStream.close();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    
    	}
    
    }
    

    附:文件转字节数组代码

    import java.io.*;
    
    /**
     * 用于文件和流转换需要
     */
    public class FileUtil {
    
    	/**
    	 * 将文件转换成byte数组
    	 * @param
    	 * @return
    	 */
    	public static byte[] file2byte(File tradeFile){
    		byte[] buffer = null;
    		try
    		{
    			FileInputStream fis = new FileInputStream(tradeFile);
    			ByteArrayOutputStream bos = new ByteArrayOutputStream();
    			byte[] b = new byte[1024];
    			int n;
    			while ((n = fis.read(b)) != -1)
    			{
    				bos.write(b, 0, n);
    			}
    			fis.close();
    			bos.close();
    			buffer = bos.toByteArray();
    		}catch (FileNotFoundException e){
    			e.printStackTrace();
    		}catch (IOException e){
    			e.printStackTrace();
    		}
    		return buffer;
    	}
    }
    

    (6)、测试效果:

    (7)、以上下载模板文件成功,总结就是后端获取静态文件,转文件流通过浏览器响应参数response来输出文件流,前端通过a标签来触发即可。学海无涯苦作舟!

     

     

     

    展开全文
  • properties文件获取工具静态加载properties配置文件,有根据key获取值的方法
  • Java实现能获取静态资源的服务器 我们平时使用Tomcat做为服务器进行Web开发,通常会输入http://localhost:8888/index.html这种URL,这种请求的Request Headers 如下: GET /index.html HTTP/1.1 Host: localhost:...

    推荐:Java网络编程汇总

    Java实现能获取静态资源的简易版服务器(类Tomcat)

    我们平时使用Tomcat做为服务器进行Web开发,通常会输入http://localhost:8888/index.html这种URL,这种请求的Request Headers 如下:

    GET /index.html HTTP/1.1
    Host: localhost:8888
    Connection: keep-alive
    Cache-Control: max-age=0
    Upgrade-Insecure-Requests: 1
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36
    Sec-Fetch-User: ?1
    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
    Sec-Fetch-Site: none
    Sec-Fetch-Mode: navigate
    Accept-Encoding: gzip, deflate, br
    Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
    

    Request Headers 可以得到请求想要访问的静态资源是index.html(我们自己实现服务器,浏览器发起请求,服务器后台得到就是Request Headers这种数据 )。

    现在我们知道如何获取请求想要的资源了(从Request Headers 获取),这就好办了。

    当用户在浏览器中输入URL发起请求,其实就是与服务器先建立网络连接,再获取服务器上的资源。
    这就和Java网络编程有关系了,现在说一说服务器主要的任务:

    • 服务器首先要打开ServerSocket,当有客户端(浏览器)进行连接,并且发起请求后,获得该请求的Request Headers (你可以把浏览器当作我们之前实现的多人聊天室里面的客户端,因为浏览器向服务器发起请求,数据也是通过流Stream或者类似的组件实现的)。
    • 服务器获得用户请求的Request Headers 后,然后从Request Headers 中分析出资源名称。
    • 知道用户想要的资源后,服务器将资源与一些必要信息打包发送给客户端(协议、状态码、资源等),当资源不存在时,服务器返回404.html资源。

    Bootstrap类,启动服务器的模块。

    import connector.Connector;
    
    public final class Bootstrap {
        public static void main(String[] args) {
            Connector connector = new Connector();
            connector.start();
        }
    }
    

    Connector类,创建ServerSocket(用于客户端建立连接)、创建Request(从Request Headers 中获取客户端请求的资源)、创建Response(将协议、状态码、资源等数据打包写入流中)、创建StaticProcessor(借助Response将资源与一些必要信息发送给服务器),代码注释应该非常清楚。

    package connector;
    
    import processor.StaticProcessor;
    
    import java.io.Closeable;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class Connector implements Runnable {
    
        private static final int DEFAULT_PORT = 8888;
    
        private ServerSocket server;
        private int port;
    
        public Connector(){
            this(DEFAULT_PORT);
        }
    
        public Connector(int port) {
            this.port = port;
        }
    
        public void start(){
            new Thread(this).start();
        }
    
        @Override
        public void run() {
            try {
                // 创建ServerSocket,绑定、监听端口
                server = new ServerSocket(port);
                System.out.println("启动服务器,监听端口:" + port);
                while(true){
                    // 等待客户端连接
                    Socket socket = server.accept();
                    // 获取输入流
                    InputStream input = socket.getInputStream();
                    // 获取输出流
                    OutputStream output = socket.getOutputStream();
    
                    // 创建请求request,并且传入输入流(有客户端请求的信息)
                    Request request = new Request(input);
                    // request通过输入流的信息,分析出客户端想要的资源
                    request.parse();
    
                    // 创建响应response,并且传入输出流(方便将获取的资源发送给客户端)
                    Response response = new Response(output);
                    // response需要request的uri(客户端请求的资源)
                    response.setRequest(request);
                    
                    // 创建处理者processor
                    StaticProcessor processor = new StaticProcessor();
                    // processor通过response把数据发送给客户端
                    processor.process(response);
    
                    //关闭socket
                    close(socket);
                }
            } catch (IOException e) {
                // 浏览器可以识别状态码,当状态码表示请求不成功时(如404),似乎会断开socket,所以这里不进行处理
            } finally{
                close(server);
            }
        }
    
        private void close(Closeable closeable){
            if(closeable != null){
                try {
                    closeable.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    Request类,从客户端与服务器建立连接的socket的输入流InputStream中读取信息,并且分析出客户端想要的资源。

    package connector;
    
    import java.io.IOException;
    import java.io.InputStream;
    
    public class Request {
    
        private static final int BUFFER_SIZE = 1024;
    
        private InputStream input;
    
        private String uri;
    
        public Request(InputStream input) {
            this.input = input;
        }
    
        public String getUri() {
            return uri;
        }
    
        public void parse(){
            int length = 0;
            byte[] buffer = new byte[BUFFER_SIZE];
            try {
                // 读取流里面的数据,并且记录长度
                length = input.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            // 将数据转化成StringBuilder
            StringBuilder request = new StringBuilder();
            for (int i = 0; i < length; i++) {
                request.append((char) buffer[i]);
            }
    
            // 分析出客户端想要的资源
            uri = parseUri(request.toString());
        }
    
        /**
         *从 “GET /index.html HTTP/1.1 
         *      ......
         *       ”中获取index.html
         * 通过空格来分离出来
         * */
        public String parseUri(String request){
            int index1 , index2;
            // 第一个空格的位置
            index1 = request.indexOf(' ');
            if(index1 != -1){
                // 第二个空格的位置
                index2 = request.indexOf(' ', index1+1);
                if(index2 != -1){
                    // 分离出资源名称
                    return request.substring(index1 + 2 , index2);
                }
            }
            // 没有办法解析出uri
            return "";
        }
    }
    

    Response类,将协议、状态码、资源等数据打包写入流中。

    package connector;
    
    import java.io.*;
    
    public class Response {
    
        private static final int BUFFER_SIZE = 1024;
        Request request;
        OutputStream output;
    
        public Response(OutputStream output) {
            this.output = output;
        }
    
        public void setRequest(Request request) {
            this.request = request;
        }
    
        public void sendStaticResource() throws IOException {
            try{
                // 通过request的uri,获取资源的路径
                String filePath = getClass()
                        .getClassLoader()
                        .getResource(request.getUri()).getFile();
                // 创建资源文件
                File file = new File(filePath.substring(1 , filePath.length()));
                // 将资源写入流里面,HttpStatus.SC_OK是状态码
                write(file , HttpStatus.SC_OK);
            } catch (Exception e) {
                // 当出现错误时,简单处理 ,发送404.html给客户端
                String errorFilePath = getClass().getClassLoader().getResource("404.html").getFile();
                // 将资源写入流里面,HttpStatus.SC_NOT_FOUND是状态码
                write(new File(errorFilePath.substring(1 , errorFilePath.length())) ,
                        HttpStatus.SC_NOT_FOUND);
    
            }
        }
    
        private void write(File resource , HttpStatus status) throws IOException {
            
            try(FileInputStream fis = new FileInputStream(resource)){
                // 先将协议、状态码等必要信息写入流中,ConnectorUtils是工具类
                output.write(ConnectorUtils.renderStatus(status).getBytes());
                byte[] buffer = new byte[BUFFER_SIZE];
                int length = 0;
                // 把资源文件写入流中
                while((length = fis.read(buffer , 0 , BUFFER_SIZE)) != -1){
                    output.write(buffer , 0 ,length);
                }
            }
        }
    }
    

    HttpStatus类,状态码枚举类。

    package connector;
    
    public enum HttpStatus {
        SC_OK(200 , "OK"),
        SC_NOT_FOUND(404 , "File Not Found");
    
        private int statusCode;
        private String reason;
    
        HttpStatus(int statusCode, String reason) {
            this.statusCode = statusCode;
            this.reason = reason;
        }
    
        public int getStatusCode() {
            return statusCode;
        }
    
        public String getReason() {
            return reason;
        }
    }
    

    ConnectorUtils类(工具类),将协议、状态码等信息组装成浏览器可以识别的信息。

    package connector;
    
    public class ConnectorUtils {
    
        public static final String PROTOCOL = "HTTP/1.1";
    
        public static final String CARRIAGE = "\r";
    
        public static final String NEWLINE = "\n";
    
        public static final String SPACE = " ";
    
        public static String renderStatus(HttpStatus status){
            StringBuilder sb = new StringBuilder(PROTOCOL)
                    .append(SPACE)
                    .append(status.getStatusCode())
                    .append(SPACE)
                    .append(status.getReason())
                    .append(CARRIAGE).append(NEWLINE)
                    .append(CARRIAGE).append(NEWLINE);
            return sb.toString();
        }
    }
    

    StaticProcessor类,做为静态资源处理者的身份,借助Response进行处理。

    package processor;
    
    import connector.Response;
    
    import java.io.IOException;
    
    public class StaticProcessor {
    
        public void process(Response response){
            try {
                response.sendStaticResource();
            } catch (IOException e) {
                // 不处理浏览器断开连接等错误
            }
        }
    }
    

    这里我们便完成了一个Java实现的能获取静态资源的简易版服务器。

    项目结构
    在这里插入图片描述
    项目源码

    Java实现获取静态资源的服务器

    测试

    请求成功,服务器有资源。
    在这里插入图片描述
    在这里插入图片描述

    请求失败,服务器没有资源。

    在这里插入图片描述

    在这里插入图片描述

    大家可以动手试一试,不用ServerSocket来实现,用NIO模型或者AIO模型的组件来实现。

    如果有说错的地方,请大家不吝赐教(记得留言哦~~~~)。

    展开全文
  • java静态类读取配置文件内容

    千次阅读 2016-12-15 16:55:30
    java静态类读取配置文件内容
  • java静态方法如何获取配置文件数据

    千次阅读 2019-10-26 15:27:12
    在我们写工具时候,经常使用静态方法,这样可以在写业务代码时候直接用工具调用其静态方法,但是在静态方法中我们无法直接获取到yml或者application等配置文件里面的数据 解决方法: 正常情况获取配置文件的...
  • 但是在我们静态资源获取xxx.properties配置文件中的值时,不能采用Spring原始注解的方法@Value(${xxxx})获取,因为Static静态资源加载的顺序在Spring容器加载之前,所以无法读取xxx.properties中的值;如果需要静态...
  • import java.io.File; import java.text.SimpleDateFormat; import java.util.Date; import javax.servlet.http.HttpServletRequest; import org.apache.commons.lang.StringUtils;... * 静态化路径工具 */ pub
  • 文件目录如下 InputStream trustcaInputStream = Resources.getResourceAsStream("cert/ca.jks"); 此时可能还是会报错 打开pom.xml,必须把文件加入打包,不然是找不到的 <resources> <...
  • 获取项目中静态文件的三种方式

    千次阅读 2019-07-09 16:23:34
    1、this.getClass().getProtectionDomain().getCodeSource().getLocation().getPath()+"/***" 2、System.getProperty("user.dir") + "/src/main/resources/***" 3、this.getClass().getClassLoader().getResource...
  • public class A{ private B b; public B getB() { return b; } public void setB(B b) { this.b = b; } static class B{ private C c; public C getC() { ...如何获取C的变量a?
  • 利用swt中的一个获取图片的SwingResourceManager 来解决将程序打为使用java打包之后,生成的jar包中图片找不着的。这是因为通过class.getResource()方法在IDEA中运行的路径和生成jar包获取的的路径是不同的。打成...
  • public class ... * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。 */ public static void readFileByBytes(String fileName) { File file = new File(fileName); InputStr...
  • 1.第一种: 引入包:import org.springframework.util....java代码:String path = ClassUtils.getDefaultClassLoader().getResource("").getPath(); 2.第二种: session.getServletContext().getRealPath("/"); ...
  • 请求需要传入文件夹路径这是后台代码importjava.io.File;importjava.io.IOException;importjava.net.MalformedURLException;importjava.util.ArrayList;importjavax.servlet.ServletException;importjavax.servlet....
  • 背景:springBoot2.1版本 ...2.创建一个对应的实体YmlBean.java,生成set,get方法 细节说明: 1,上加注解@Configuration; 2,在set方法上加@Value("${XXX}"),其中XXX与yml文件对应。有层级关系的话用.隔开;...
  • 通过set方法进行赋值 yml: spring datasource ...java类: public class DbHelper(){ private static String url; @Value("${spring.datesource.url}") public void setUrl(String url) { DbHelper...
  • 将test.properties的文件读取赋值给静态变量 创建一个final 可以两种方式读取test.properties配置文件 第一种:此方法可以写配置文件的绝对路径 InputStream is = new BufferedInputStream(new ...
  • SpringBoot直接URL获取静态资源文件

    万次阅读 2019-06-14 19:06:15
    SpringBoot直接URL获取静态资源文件 spring boot 直接通过url访问获取内部或者外部静态资源图片 https://blog.csdn.net/ljj_9/article/details/79650008 第一种方式,在代码上配置 @Configuration publicclass ...
  • JAVA反射静态内部的属性

    千次阅读 2018-11-09 11:47:48
    我这个很特别:Config中存在好多静态内部静态内部中全部是静态属性,如何将jsonobject值反射到属性上来? 1、Config public class Config { public static class Main { public static boo...
  • Java程序要使用某个时,如果该还未被加载到内存中,则系统会通过加载、连接、初始化三步来实现对这个进行初始化。 加载:就是指将的class文件读入内存,并为之创建一个Class对象。任何被使用时,系统...
  • java获取项目中文件

    千次阅读 2020-06-25 15:01:18
    查看资料项目中获取资源文件路径 1、xxx.class.getClassLoader().getResource(“”).getPath(); 获取src资源文件编译后的路径(即classes路径) 2、xxx.class.getClassLoader().getResource(“文件”).getPath(); ...
  • 问大家一个问题,列如我在前端可以通过htpps://10.62.192.31943/eam/icons/domain/domain-12.jpg这个url来访问获取这张图片,但是这个...不是后台的真实路径,请问我怎么通过这个获取文件流,之前试过用url那种方式不行
  • 在jar包中获取静态资源文件

    千次阅读 2018-11-29 16:50:12
    在本地编辑器上运行/resources/static/images/下的图片通过路径来获取 File images = new File(path.getAbsolutePath(), "static/images/logo.jpg"); 但是项目打包发布上服务器后,访问就报路径为空。 ...
  • java静态方法中读取某个配置文件中的配置 注意: application-dev.yml 配置文件名称 accout 配置文件中配置项key public static void main(String[] args) throws IOException { Properties props = new Properties...
  • 首先,获取资源属性的方式有很多种,这里先介绍两种:Abc.class.getClassLoader().getResourceAsStream(String name);...其次,为什么要选择使用静态代码块来获取资源呢?因为它只需要在应用被启动或者是第一次
  • //第一种 package org.springframework.util; URL url = ClassUtils.getDefaultClassLoader().getResource("classpath:static/image/"+ srcImgName); //第二种 package org.springframework.core.io;...
  • springboot如何在静态类获取配置? 以下所有示例都通过验证。 1.定义配置文件格式 这里主要指常见的配置文件:properties, yaml. 当然,json也可以作为配置,不过不是首选。 使用的配置文件: application....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 346,087
精华内容 138,434
关键字:

java通过类去获取静态文件

java 订阅