木子-后端-Java小知识点

目录

* java对象转Object类型、object对象转换为自定义对象、Json数据转成List数据

* 如何将一个声明好的对象转成Map,object>

* 如何将一个未声明好的Object对象转成Map,object>

* 富文本KindEditor图片上传后台接收存入服务器并返回的方法

* java后端根据url获取页面信息

* java前端传入json字符串格式实体类或字符串格式集合时后台如何接收

* 如何将异常中的e.printstacktrace()转成String格式

* 通过java执行杀死电脑某一程序操作

将网络图片转为base64格式

---

* java对象转Object类型、object对象转换为自定义对象、Json数据转成List数据

对象转Object格式

//list.get(0)你可以理解为一个对象，list=List<xxx.class>();只是没有写明而已
Object o = JSONObject.toJSON(list.get(0));

object转自定义对象

//自定义对象 xx=JSON.parseObject(JSON.toJSONString(要转换的Object类型对象)，自定义对象.class）
SysUserBean ss=JSON.parseObject(JSON.toJSONString(o),SysUserBean.class);

//也可以使用此方法转成Map类型，前提是你的数据格式是Map
Map<String,Object>map= JSON.parseObject(text);

json数据转成List

toJsonString是转成Json字符串。。因为我的原本不是，主要是parseArray

List<Object>list=JSONObject.parseArray(JSON.toJSONString(dataMap.get("extendedFields")));

/

* 如何将一个声明好的对象转成Map<String,Object>

bean就是你的对象

    /**
     * 将实体类转成Map
     * @param bean
     * @User 木子
     */
    public static Map<String, Object> beanToMap(Object bean) {
        Map<String, Object> map = Maps.newHashMap();
        if (bean != null) {
            BeanMap beanMap = BeanMap.create(bean);
            for (Object key : beanMap.keySet()) {
                map.put(key+"", beanMap.get(key));
            }
        }
      return map;
    }

/

* 如何将一个未声明好的Object对象转成Map<String,Object>

太多代码就不给展示了只给展示核心部分的了

// 此参数是我从一个数据内获取到的，由于没有声明对象信息，所以无法转成一个对象走上一个步骤方法
Object xiaxing=dataMap.get("inBound");

// 下方标//--------------区域内是负责将Object对象转成Map的部分，其余部分无用

    if(xiaxing!=null){
         Map<String,Object>xiaxingMap= new HashMap<>();
//-----------------
         Iterator it =JSON.parseObject(String.valueOf(xiaxing)).entrySet().iterator();
         while (it.hasNext()) {
               Map.Entry<String, Object> entry = (Map.Entry<String, Object>) it.next();
               xiaxingMap.put(entry.getKey(), entry.getValue());
         }
//-----------------
         xiaxingMap.put("type", 1);
         xiaxingMap.put("lxId", dataMap.get("id"));
         shangxiaxings.add(xiaxingMap);
    }

/

* 富文本KindEditor图片上传后台接收存入服务器并返回的方法

我没有使用图片服务器，不是没用，是上传失败了，但是我用本地上传好用，因为上传服务器要用公司的通用方法，所以只能无奈放弃测试了

前端：调用方法将图片传入后端，因为我接手时前端已经较为完整只是上传图片无法使用，这里只写一丢丢，没头没尾

因为我侧重的时后台的写入

uploadJson：后台的上传图片的路径

 KindEditor.ready(function(K) {
        editor = K.create('textarea[name="content"]',{
            // uploadJson : '../goodsManage/uploadImg',
            allowImageUpload :true,
            uploadJson : '../fwb/uploadImgTwo',
        });

后端：富文本格式返给后台的不是一个临时文件，而是存在request中，我们需要将request转成临时文件

    /**
     * 上传照片
     *
     * @return
     */
    @RequestMapping("uploadImgTwo")
    @ResponseBody
    public String uploadImgTwo(HttpServletRequest request, HttpServletResponse response) {

        //文件保存目录路径
        String savePath = "D://666/";

        //文件保存目录URL这个不能用文件夹路径，就算你的文件夹下确实又这张图片也会无效的，要用
        //域名/ip那样子的
        String saveUrl = "D://666/";
        //定义允许上传的文件扩展名
        HashMap<String, String> extMap = new HashMap<String, String>();
        extMap.put("image", "gif,jpg,jpeg,png,bmp");
        extMap.put("flash", "swf,flv");
        extMap.put("media", "swf,flv,mp3,wav,wma,wmv,mid,avi,mpg,asf,rm,rmvb");
        extMap.put("file", "doc,docx,xls,xlsx,ppt,htm,html,txt,zip,rar,gz,bz2");
        //最大文件大小
        long maxSize = 1000000;

        if(!ServletFileUpload.isMultipartContent(request)){
            System.out.println(getError("请选择文件。"));
            return getError("请选择文件。");
        }
        //检查目录
        File uploadDir = new File(savePath);
        if(!uploadDir.isDirectory()){
            System.out.println(getError("上传目录不存在。"));
            return getError("上传目录不存在。");
        }
        //检查目录写权限
        if(!uploadDir.canWrite()){
            System.out.println(getError("上传目录没有写权限。"));
            return getError("上传目录没有写权限。");
        }
        String dirName = request.getParameter("dir");
        if (dirName == null) {
            dirName = "image";
        }
        if(!extMap.containsKey(dirName)){
            System.out.println(getError("目录名不正确。"));
            return getError("目录名不正确。");
        }
//        //创建文件夹
        savePath += dirName + "/";
        saveUrl += dirName + "/";
        File saveDirFile = new File(savePath);
        if (!saveDirFile.exists()) {
            saveDirFile.mkdirs();
        }

        FileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(factory);
        upload.setHeaderEncoding("UTF-8");
        //这一步将request强转
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;

        Iterator item = multipartRequest.getFileNames();

        while (item.hasNext()) {

            String fileName = (String) item.next();
            //根据文件名获取临时文件信息
            MultipartFile file = multipartRequest.getFile(fileName);
            // 检查文件大小
            if (file.getSize() > maxSize) {
                return getError("上传文件大小超过限制。");
            }

            // 检查扩展名
            String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".") + 1).toLowerCase();

            if (!Arrays.asList(extMap.get(dirName).split(",")).contains(fileExt)) {
                return getError("上传文件扩展名是不允许的扩展名。\n只允许"
                        + extMap.get(dirName) + "格式。");

            }
            SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");

            String newFileName = df.format(new Date()) + "_" + new Random().nextInt(1000) + "." + fileExt;

            try {

                File uploadedFile = new File(savePath, newFileName);

                ByteStreams.copy(file.getInputStream(), new FileOutputStream(uploadedFile));

            } catch (Exception e) {

                return getError("上传文件失败。");

            }

                JSONObject obj = new JSONObject();
                obj.put("error", 0);
                obj.put("url", saveUrl + newFileName);
                System.out.println(obj.toJSONString());
                return obj.toJSONString();
            }
            return null;
}


//异常时返回信息
    private String getError(String message) {
        JSONObject obj = new JSONObject();
        obj.put("error", 1);
        obj.put("message", message);
        return obj.toJSONString();
    }

/

* java后端根据url获取页面信息

//最新方法：Document doc = Jsoup.connect(URL).timeout(2000).get();

SendGET的方法实际上和我上面标红的部分是一样的，写了上面那句就不需要写SendGET（）的一串了

 public String SendGET() {
        //访问返回结果
        BufferedReader read = null;//读取访问结果
        String result = "";
        try {
            //创建url
            URL realurl = new URL("https://123/bing/sssss.html");


            //打开连接
            URLConnection connection = realurl.openConnection();
            // 设置通用的请求属性
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent",
                    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            //建立连接
            connection.connect();
            // 获取所有响应头字段
            Map<String, List<String>> map = connection.getHeaderFields();
            // 遍历所有的响应头字段，获取到cookies等
            for (String key : map.keySet()) {
                System.out.println(key + "--->" + map.get(key));
            }
            // 定义 BufferedReader输入流来读取URL的响应
            read = new BufferedReader(new InputStreamReader(
                    connection.getInputStream(), "UTF-8"));
            String line;//循环读取
            while ((line = read.readLine()) != null) {
                result += line;//result就是页面的数据
            }

            //详细获取数据已完成，怎样将数据转成对象获取详细信息看下一内容
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (read != null) {//关闭流
                try {
                    read.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

            Document doc = Jsoup.parse(result);//html页面转成对象

            Elements contentsss = doc.getElementsByClass("类似前端根据class获取");
            String ssss=contentsss.get(0).toString();
            String[]s1=ssss.split("<h3>");
            String[]s2=s1[1].split("</h3>");
            String s3=s2[0];
            Elements content = doc.getElementsByClass("item-link");
            String linkHref;
            String linkText;
            for (Element link : content) {
                linkHref = link.attr("href");//attr可以获取标签的参数
                linkText = link.attr("data-title");
         
                        AquacultureDiseasesBean ssd=new AquacultureDiseasesBean();
      
                        ssd.setDiseasesName(linkText);
                      
                        ssd.setIndustryType("2");
                        ssd.setDiseasesRole("0");
                        expertManageService.saveDisease(ssd);

            }

/

* java前端传入json字符串格式实体类或字符串格式集合时后台如何接收

首先先放上前端代码：

//实体类 
let task={
        taskName:'',
        file:''
    };

//集合
let list.push(task);
list.push(task);

//转字符串：
    task=JSON.stringify(task);
    taskLeaderList=JSON.stringify(list);

//ajax传值方式：
 $.ajax({
        url: "/rdManager/addRdManager",
        type: "POST",
        data:{
            task:task,
            taskLeaderList:taskLeaderList
        },

//接下来进行后端解析，因为JSON.stringify会将参数转成字符串格式，所以后端接收需要用String格式接收

  @ResponseBody
    @RequestMapping("addRdManager")
    public ResultObject addRdManager(String task, String taskLeaderList) {
        try {
            //实体类格式字符串转成对象
            TaskBean taskBean = JSON.parseObject(task, TaskBean.class);

            //字符串转换方式
            JSONArray tagsArray = JSONArray.parseArray(taskLeaderList);
            List<TaskLeaderBean> taskLeaderBeans = new ArrayList<>();
            for (int i = 0; i < tagsArray.size(); i++) {
                JSONObject jsonObject = tagsArray.getJSONObject(i);
                TaskLeaderBean taskLeaderBean                     
                               =jsonObject.toJavaObject(TaskLeaderBean.class);
                taskLeaderBeans.add(taskLeaderBean);
            }

/

* 如何将异常中的e.printstacktrace()转成String格式

调用下列方法，传入e即可

/**
     * 获取e.printStackTrace() 的具体信息，赋值给String 变量，并返回
     *
     * @param e
     *            Exception
     * @return e.printStackTrace() 中 的信息
     */
    public static String getStackTraceInfo(Exception e) {

        StringWriter sw = null;
        PrintWriter pw = null;

        try {
            sw = new StringWriter();
            pw = new PrintWriter(sw);
            e.printStackTrace(pw);//将出错的栈信息输出到printWriter中
            pw.flush();
            sw.flush();

            return sw.toString();
        } catch (Exception ex) {

            return "发生错误";
        } finally {
            if (sw != null) {
                try {
                    sw.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            if (pw != null) {
                pw.close();
            }
        }

    }

/

* 通过java执行杀死电脑某一程序操作

调用killProc方法参数值processName为需要杀死的程序名字

  /**
     * @desc 杀死进程
     * @author zp
     * @throws IOException
     * @date 2018-3-29
     */
    public static void killProc(String processName) throws IOException {
        if (processName != null && processName.length() > 0 && processName.trim().length() > 0) {
            executeCmd("taskkill /F /IM " + processName);
        }
    }

    /**
     * @desc 执行cmd命令
     * @author zp
     * @date 2018-3-29
     */
    public static String executeCmd(String command) throws IOException {
        Runtime runtime = Runtime.getRuntime();

        Process process = runtime.exec("cmd /c " + command);
        BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream(), "UTF-8"));
        String line = null;
        StringBuilder build = new StringBuilder();
        while ((line = br.readLine()) != null) {
            build.append(line);
        }
        return build.toString();
    }

/

将网络图片转为base64格式

返回的base64没有前缀，需要我们自己去加
String url="data:image/png;base64,"+ImageBase64("https://img-blog.csdnimg.cn/24828250aeca4b38b7d2d1847ccc4df4.png");


private static String ImageBase64(String imgUrl) {
        URL url = null;
        InputStream is = null;
        ByteArrayOutputStream outStream = null;
        HttpURLConnection httpUrl = null;
        try{
            url = new URL(imgUrl);
            httpUrl = (HttpURLConnection) url.openConnection();
            httpUrl.connect();
            httpUrl.getInputStream();
            is = httpUrl.getInputStream();

            outStream = new ByteArrayOutputStream();
            //创建一个Buffer字符串
            byte[] buffer = new byte[1024];
            //每次读取的字符串长度，如果为-1，代表全部读取完毕
            int len = 0;
            //使用一个输入流从buffer里把数据读取出来
            while( (len=is.read(buffer)) != -1 ){
                //用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度
                outStream.write(buffer, 0, len);
            }
            // 对字节数组Base64编码
            // java11与后面版本用这个
            return new Base64Util().encode(outStream.toByteArray());
            // java11之前用这个
            return new BASE64Encoder().encode(outStream.toByteArray());
        }catch (Exception e) {
            e.printStackTrace();
        }
        finally{
            if(is != null)
            {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(outStream != null)
            {
                try {
                    outStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(httpUrl != null)
            {
                httpUrl.disconnect();
            }
        }
        return imgUrl;
    }

/