首页 > 编程开发 > Java

java实现即时通信的完整步骤分享

来自：网络
时间：2020-10-14
阅读：

前言

移动社交是我们日常生活中很常见的软件，最近在做即时通信，我用的是环信，和大家分享一下~~
环信的API都是基于JSON的，所以在构造HTTP请求的时候，要指定请求头：

java实现即时通信的完整步骤分享
java实现即时通信的完整步骤分享

注意==》环信API必须携带token才可以访问。

创建一个认证类

	public class Authentic {

 private static Token token = new Token();

 private TalkHttpService service;

 public Authentic(TalkHttpService service) {
 this.service = service;
 }

 public Authentic(TalkHttpService service, Token token) {
 this.service = service;
 if (token != null) {
  Authentic.token = token;
 }
 }

 public Token getToken() {
 this.flush();
 return token;
 }

 public void task() {
 this.flush();
 }

 /**
 * @describe 申请认证 POST PUT 这两种请求携带参数
 * @author 何章怀晓 hezhanghuaixiao
 * @date 2020/9/8 17:02
 * @other
 */
 public void applyAuthentication(HttpEntityEnclosingRequestBase request) {
 this.flush();
 request.addHeader("Authorization", "Bearer " + token.toString());
 }
 /**
 * @describe 申请认证 GET DELETE 这两种请求不携带参数
 * @author 何章怀晓 hezhanghuaixiao
 * @date 2020/9/8 17:02
 * @other
 */
 public void applyAuthentication(HttpRequestBase request) {
 this.flush();
 request.addHeader("Authorization", "Bearer " + token.toString());
 }

 private void flush() {
 synchronized (Authentic.class) {
  try {
  //如果超时
  if (token.isExpire()) {
   //判断APPID和秘钥信息
   if (_Global.APP_CLIENT_ID != null && _Global.APP_CLIENT_SECRET != null) {
   Map<String, Object> param = new HashMap<String, Object>();
   param.put("grant_type", "client_credentials");
   param.put("client_id", _Global.APP_CLIENT_ID);
   param.put("client_secret", _Global.APP_CLIENT_SECRET);
   //请求获取token
   TalkNode res = service
    .request(_Global.URR_TOKEN, _Global.HTTP_METHOD_POST, param, null, null);
   //成功获取token
   if (res != null && res.getAccess_token() != null && res.getExpires_in() != null
    && res.getExpires_in() > 0) {
    //赋值
    token = new Token(res.getAccess_token(),
     res.getExpires_in() * 1000 + System.currentTimeMillis());
   }
   }
  }
  } catch (Exception e) {
  e.printStackTrace();
  }
 }
 }

 public static class Token {

 private String token;
 private Long expire;

 public Token() {
 }

 public Token(String token, long expire) {
  this.token = token;
  this.expire = expire;
 }

 public String getToken() {
  return token;
 }

 public void setToken(String token) {
  this.token = token;
 }

 public Long getExpire() {
  return expire;
 }

 public void setExpire(Long expire) {
  this.expire = expire;
 }

 public boolean isExpire() {
  return expire == null || System.currentTimeMillis() > expire;
 }

 @Override
 public String toString() {
  return token;
 }
 }
}

创建请求接口

public interface TalkHttpService {
	/**
	 @describe
	 @param
		* @param url 请求地址

	 * @param method	请求方法

	 * @param param	参数

	 * @param auth	加密认证

	 * @param field	字段转换
	 @return com.hedashi.protal.model.TalkNode
	 @author 何章怀晓 hezhanghuaixiao
	 @date 2020/9/8 17:21
	 @other
	 */
	 TalkNode request(String url, int method, Object param,
  Authentic auth, String[][] field) throws Exception;

	/**
	 @describe
	 @param
		* @param url 请求地址

	 * @param file	文件名称

	 * @param auth	加密认证

	 * @param equal	字段转换
	 @return com.hedashi.protal.model.TalkNode
	 @author 何章怀晓 hezhanghuaixiao
	 @date 2020/9/8 17:21
	 @other
	 */
	 TalkNode upload(String url, File file, Authentic auth,
  String[][] equal) throws Exception;


	/**
	 @describe
	 @param
		* @param url 请求地址

	 * @param file	文件名称

	 * @param auth	加密认证

	 * @param header	请求头
	 @return void
	 @author 何章怀晓 hezhanghuaixiao
	 @date 2020/9/8 17:21
	 @other
	 */
	 void downLoad(String url, File file, Authentic auth,
  Map<String, String> header) throws Exception;

}

创建全局变量对不同模块操作

/*
 @describe 全局变量
 @params
 @return 
 @author 何章怀晓
 @date 2020/7/30 9:30
 @other
 */
public class _Global {
	
	public static String APP_KEY = "";
	public static String APP_CLIENT_ID = "";
	public static String APP_CLIENT_SECRET = "";
	//每页数量
	public static int APP_PAGE_SIZE = 10;
	public static final int HTTP_METHOD_GET = 1;
	public static final int HTTP_METHOD_POST = 2;
	public static final int HTTP_METHOD_PUT = 3;
	public static final int HTTP_METHOD_DELETE = 4;
	public static final String URL_HOST = "http://a1.easemob.com/"+APP_KEY.replace("#","/")+"/";
	public static final String URR_TOKEN = URL_HOST+"token";
	public static final String URL_CHAT = URL_HOST+"chatmessages";
	public static final String URL_GROUP = URL_HOST+"chatgroups";
	public static final String URL_FILE = URL_HOST+"chatfiles";
	public static final String URL_ROOM = URL_HOST+"chatrooms";
	public static final String URL_MESSAGES = URL_HOST+"messages";
	public static final String URL_USER = URL_HOST+"users";
	
}

请求管理类

package com.hedashi.protal.service.impl;


import com.hedashi.protal.model.TalkNode;
import com.hedashi.protal.model.Authentic;
import com.hedashi.protal.service.TalkHttpService;
import com.hedashi.protal.util.JsonTool;
import com.hedashi.protal.util._Global;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.URI;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntity;
import org.apache.http.entity.mime.content.ContentBody;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.stereotype.Service;

@Service
public class TalkHttpServiceImplApache implements TalkHttpService {
 /**
 @describe
 @param
 * @param url 请求路径

 * @param method 方式

 * @param param 参数

 * @param auth 认证

 * @param field 将相应结果封装到本地
 @return com.hedashi.protal.model.TalkNode
 @author 何章怀晓 hezhanghuaixiao
 @date 2020/9/8 17:39
 @other
 */
 @Override
 public TalkNode request(String url, int method, Object param,
  Authentic auth, String[][] field) throws Exception {

 //获得可关闭的连接
 CloseableHttpClient client = this.getClient();
 try {
  HttpResponse response = null;
  //区分请求方式
  switch (method) {
  case _Global.HTTP_METHOD_GET:
   //构建请求
   HttpGet get = new HttpGet(url);
   if (auth != null) {
   //如果未认证 请求认证
   auth.applyAuthentication(get);
   }
   //固定请求头信息为JSON
   get.addHeader("Content-Type", "application/json");
   response = client.execute(get);
   break;
  case _Global.HTTP_METHOD_POST:
   HttpPost post = new HttpPost(url);
   if (auth != null) {
   auth.applyAuthentication(post);
   }
   //POST携带参数
   if (param != null) {
   //参数编码放入请求体
   post.setEntity(new StringEntity(JsonTool.write(param),
    "UTF-8"));
   }
   post.addHeader("Content-Type", "application/json");
   response = client.execute(post);
   break;
  case _Global.HTTP_METHOD_PUT:
   HttpPut put = new HttpPut(url);
   if (put != null) {
   auth.applyAuthentication(put);
   }
   if (param != null) {
   put.setEntity(new StringEntity(JsonTool.write(param),
    "UTF-8"));
   }
   put.addHeader("Content-Type", "application/json");
   response = client.execute(put);
   break;
  case _Global.HTTP_METHOD_DELETE:
   HttpDelete delete = new HttpDelete(url);
   if (auth != null) {
   auth.applyAuthentication(delete);
   }
   delete.addHeader("Content-Type", "application/json");
   response = client.execute(delete);
   break;
  default:
   throw new Exception("非法请求方式");
  }
  int code = response.getStatusLine().getStatusCode();
  //判断返回code 如果为200
  if (code == HttpStatus.SC_OK) {
  //获取响应体
  HttpEntity entity = response.getEntity();
  if (entity != null) {
   //解析
   String json = EntityUtils.toString(entity, "UTF-8");
   if (field != null && field.length > 0) {
   for (String[] temp : field) {
    json = json.replace(temp[0], temp[1]);
   }
   }
   //解析为实体类
   TalkNode talkNode = (TalkNode) JsonTool.read(json, TalkNode.class);
   talkNode.setStatusCode(code);
   return talkNode;
  }
  } else {
  //非200将code返回
  return new TalkNode(code);
  }
 } catch (Exception e) {
  throw e;
 } finally {
  client.close();
 }
 return null;
 }

 @Override
 public TalkNode upload(String url, File file, Authentic auth,
  String[][] equal) throws Exception {
 CloseableHttpClient client = this.getClient();
 try {
  HttpPost post = new HttpPost();
  post.setURI(new URI(url));
  if (auth != null) {
  auth.applyAuthentication(post);
  }
  post.addHeader("restrict-access", "true");
  ContentBody body = new FileBody(file);
  MultipartEntity part = new MultipartEntity();
  part.addPart("file", body);
  post.setEntity(part);
  HttpResponse response = client.execute(post);
  int code = response.getStatusLine().getStatusCode();
  if (code == HttpStatus.SC_OK) {
  HttpEntity entity = response.getEntity();
  if (entity != null) {
   String json = EntityUtils.toString(entity, "UTF-8");
   if (equal != null && equal.length > 0) {
   for (String[] temp : equal) {
    json = json.replace(temp[0], temp[1]);
   }
   }

   TalkNode talkNode = (TalkNode) JsonTool.read(json, TalkNode.class);
   talkNode.setStatusCode(code);
   return talkNode;
  }
  }
 } catch (Exception e) {
  throw e;
 } finally {
  client.close();
 }
 return null;
 }

 @Override
 public void downLoad(String url, File file, Authentic auth,
  Map<String, String> header) throws Exception {
 CloseableHttpClient client = this.getClient();
 try {
  HttpGet get = new HttpGet();
  get.setURI(new URI(url));
  if (auth != null) {
  auth.applyAuthentication(get);
  }
  for (Entry<String, String> en : header.entrySet()) {
  get.addHeader(en.getKey(), en.getValue());
  }
  HttpResponse response = client.execute(get);
  if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
  HttpEntity entity = response.getEntity();
  if (entity != null) {
   InputStream in = entity.getContent();
   FileOutputStream fos = new FileOutputStream(file);
   byte[] data = new byte[10 * 1024];
   int len = 0;
   while ((len = in.read(data)) != -1) {
   fos.write(data, 0, len);
   }
   fos.flush();
   fos.close();
   in.close();
  }
  }
 } catch (Exception e) {
  throw e;
 } finally {
  client.close();
 }
 }

 private CloseableHttpClient getClient() {
 return HttpClients.createDefault();
 }
}

创建业务请求和响应格式类

package com.hedashi.protal.model;

import java.util.List;
import java.util.Map;
/**
 @describe 根据不同的业务封装不同的返回结果，该格式在发送请求的时候就被指定
 @author 何章怀晓 hezhanghuaixiao
 @date 2020/9/8 17:42
 @other
 */
public class TalkNode {

 public static final String[][] DATA_ENTITIES = new String[][]{{"entities", "entities_share"},
  {"share-secret", "share_secret"}};
 public static final String[][] DATA_ARRAY = new String[][]{{"data", "data_array"}};
 public static final String[][] DATA_LIST = new String[][]{{"data", "data_list"}};
 public static final String[][] DATA_MAP = new String[][]{{"data", "data_map"}};
 public static final String[][] DATA_CHAT_LIST = new String[][]{{"entities", "data_chat_list"}};
 public static final String[][] DATA_ROOM = new String[][]{{"data", "data_room"}};
 public static final String[][] DATA_ROOM_LIST = new String[][]{{"data", "data_room_list"},
  {"public", "public_room"}};
 public static final String[][] DATA_ROOM_REDO = new String[][]{{"data", "data_room_rodo"}};
 public static final String[][] DATA_ROOM_REDO_LIST = new String[][]{
  {"data", "data_room_redo_list"}};
 public static final String[][] DATA_GROUP = new String[][]{{"data", "data_group"}};
 public static final String[][] DATA_GROUP_UPDATE = new String[][]{{"data", "data_group_update"}};
 public static final String[][] DATA_GROUP_OWNER = new String[][]{{"data", "data_group_owner"}};
 public static final String[][] DATA_GROUP_LIST = new String[][]{{"data", "data_group_list"}};
 public static final String[][] DATA_GROUP_LIST_MEMBER = new String[][]{
  {"data", "data_group_list_member"}};
 public static final String[][] DATA_GROUP_LIST_NEW = new String[][]{
  {"data", "data_group_list_new"}, {"public", "public_group"}};
 public static final String[][] DATA_GROUP_FRIEND = new String[][]{{"data", "data_group_friend"}};
 public static final String[][] DATA_GROUP_FRIEND_LIST = new String[][]{
  {"data", "data_group_friend_list"}};
 private String access_token;
 private String action;
 private String application;
 private String applicationName;
 private Long count;
 private String cursor;
 private Integer duration;
 private Long expires_in;
 private String organization;
 private String path;
 private Integer statusCode;
 private Long timestamp;
 private String uri;
 private Map<String, Object> params;
 private TalkUser user;
 private List<TalkUser> entities;
 private String[] data_array;
 private Map<String, String> data_map;
 private List<Map<String, Object>> data_list;
 private List<TalkMsg> data_chat_list;
 private TalkRoom data_room;
 private List<TalkRoom> data_room_list;
 private TalkRoomRedo data_room_rodo;
 private List<TalkRoomRedo> data_room_redo_list;
 private TalkGroup data_group;
 private TalkGroupMember data_group_update;
 private TalkGroupMember data_group_owner;
 private List<TalkGroup> data_group_list;
 private List<TalkGroupMember> data_group_list_member;
 private List<TalkGroupNew> data_group_list_new;
 private TalkGroupFriend data_group_friend;
 private List<TalkGroupFriend> data_group_friend_list;

 public TalkNode() {
 }


 public TalkNode(Integer statusCode) {
 this.statusCode = statusCode;
 }

 public String getAccess_token() {
 return access_token;
 }

 public void setAccess_token(String access_token) {
 this.access_token = access_token;
 }

 public String getAction() {
 return action;
 }

 public void setAction(String action) {
 this.action = action;
 }

 public String getApplication() {
 return application;
 }

 public void setApplication(String application) {
 this.application = application;
 }

 public String getApplicationName() {
 return applicationName;
 }

 public void setApplicationName(String applicationName) {
 this.applicationName = applicationName;
 }

 public Long getCount() {
 return count;
 }

 public void setCount(Long count) {
 this.count = count;
 }

 public String getCursor() {
 return cursor;
 }

 public void setCursor(String cursor) {
 this.cursor = cursor;
 }

 public Integer getDuration() {
 return duration;
 }

 public void setDuration(Integer duration) {
 this.duration = duration;
 }

 public Long getExpires_in() {
 return expires_in;
 }

 public void setExpires_in(Long expires_in) {
 this.expires_in = expires_in;
 }

 public String getOrganization() {
 return organization;
 }

 public void setOrganization(String organization) {
 this.organization = organization;
 }

 public String getPath() {
 return path;
 }

 public void setPath(String path) {
 this.path = path;
 }

 public Integer getStatusCode() {
 return statusCode;
 }

 public void setStatusCode(Integer statusCode) {
 this.statusCode = statusCode;
 }

 public Long getTimestamp() {
 return timestamp;
 }

 public void setTimestamp(Long timestamp) {
 this.timestamp = timestamp;
 }

 public String getUri() {
 return uri;
 }

 public void setUri(String uri) {
 this.uri = uri;
 }

 public Map<String, Object> getParams() {
 return params;
 }

 public void setParams(Map<String, Object> params) {
 this.params = params;
 }

 public TalkUser getUser() {
 return user;
 }

 public void setUser(TalkUser user) {
 this.user = user;
 }

 public List<TalkUser> getEntities() {
 return entities;
 }

 public void setEntities(List<TalkUser> entities) {
 this.entities = entities;
 }

 public String[] getData_array() {
 return data_array;
 }

 public void setData_array(String[] data_array) {
 this.data_array = data_array;
 }

 public Map<String, String> getData_map() {
 return data_map;
 }

 public void setData_map(Map<String, String> data_map) {
 this.data_map = data_map;
 }

 public List<Map<String, Object>> getData_list() {
 return data_list;
 }

 public void setData_list(List<Map<String, Object>> data_list) {
 this.data_list = data_list;
 }

 public List<TalkMsg> getData_chat_list() {
 return data_chat_list;
 }

 public void setData_chat_list(List<TalkMsg> data_chat_list) {
 this.data_chat_list = data_chat_list;
 }

 public TalkRoom getData_room() {
 return data_room;
 }

 public void setData_room(TalkRoom data_room) {
 this.data_room = data_room;
 }

 public List<TalkRoom> getData_room_list() {
 return data_room_list;
 }

 public void setData_room_list(List<TalkRoom> data_room_list) {
 this.data_room_list = data_room_list;
 }

 public TalkRoomRedo getData_room_rodo() {
 return data_room_rodo;
 }

 public void setData_room_rodo(TalkRoomRedo data_room_rodo) {
 this.data_room_rodo = data_room_rodo;
 }

 public List<TalkRoomRedo> getData_room_redo_list() {
 return data_room_redo_list;
 }

 public void setData_room_redo_list(List<TalkRoomRedo> data_room_redo_list) {
 this.data_room_redo_list = data_room_redo_list;
 }

 public TalkGroup getData_group() {
 return data_group;
 }

 public void setData_group(TalkGroup data_group) {
 this.data_group = data_group;
 }

 public TalkGroupMember getData_group_update() {
 return data_group_update;
 }

 public void setData_group_update(TalkGroupMember data_group_update) {
 this.data_group_update = data_group_update;
 }

 public TalkGroupMember getData_group_owner() {
 return data_group_owner;
 }

 public void setData_group_owner(TalkGroupMember data_group_owner) {
 this.data_group_owner = data_group_owner;
 }

 public List<TalkGroup> getData_group_list() {
 return data_group_list;
 }

 public void setData_group_list(List<TalkGroup> data_group_list) {
 this.data_group_list = data_group_list;
 }

 public List<TalkGroupMember> getData_group_list_member() {
 return data_group_list_member;
 }

 public void setData_group_list_member(
  List<TalkGroupMember> data_group_list_member) {
 this.data_group_list_member = data_group_list_member;
 }

 public List<TalkGroupNew> getData_group_list_new() {
 return data_group_list_new;
 }

 public void setData_group_list_new(List<TalkGroupNew> data_group_list_new) {
 this.data_group_list_new = data_group_list_new;
 }

 public TalkGroupFriend getData_group_friend() {
 return data_group_friend;
 }

 public void setData_group_friend(TalkGroupFriend data_group_friend) {
 this.data_group_friend = data_group_friend;
 }

 public List<TalkGroupFriend> getData_group_friend_list() {
 return data_group_friend_list;
 }

 public void setData_group_friend_list(
  List<TalkGroupFriend> data_group_friend_list) {
 this.data_group_friend_list = data_group_friend_list;
 }
}

工具类

public class HuanXinUtil {

	private static TalkDataService service = null;

	/**
	 @describe 初始化
	 @param
		* @param
	 @return void
	 @author 何章怀晓 hezhanghuaixiao
	 @date 2020/9/8 17:26
	 @other
	 */
	private static void init(){

		if(service == null){
			
			// 初始服务端Token
			Authentic.Token token = new Authentic(new TalkHttpServiceImplApache()).getToken();
			//token和过期时间
			Authentic.Token TEST_TOKEN = new Authentic.Token(token.getToken(),token.getExpire());
			//新建一个链接服务
			service = new TalkDataServiceImpl(new TalkHttpServiceImplApache());
			// 修改数据业务Token
			service.setToken(TEST_TOKEN);
		}
	}

	/**
		 @describe 添加管理员
		 @param
		 * @param groupId 群组id

		 * @param userid 管理员id
		 @return boolean
		 @author 何章怀晓 hezhanghuaixiao
		 @date 2020/9/8 17:54
		 @other
		 */
	public static boolean addGroupManager(String groupId,String userid) {
		try {
			init();
			TalkNode talkNode = service.addGroupManager(groupId,userid);
			if(talkNode.getStatusCode()==200){
				return true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	}
	}

service调用

 @Override
 public TalkNode addGroupManager(String id, String userId) throws Exception {
 Map<String, Object> param = new HashMap<String, Object>();
 param.put("newadmin", userId);
 return service.request(_Global.URL_GROUP + "/" + id + "/admin",
  _Global.HTTP_METHOD_POST, param, auth, TalkNode.DATA_GROUP);
 }

 /**
 * @param [groupId, managerId]
 * @return com.hedashi.common.api.CommonResult
 * @describe 后台添加群组管理员
 * @author 何章怀晓 hezhanghuaixiao
 * @date 2020/9/8 14:28
 * @other
 */
 @Override
 public CommonResult addGroupManager(String groupId, String managerId) {
 boolean b = HuanXinUtil.addGroupManager(groupId, managerId);
 if(b){
  System.out.println("环信添加管理员成功==========================");
  //本地添加管理员
  addGroupAdmin(groupId,managerId);
  return CommonResult.success("SUCCESS");
 }
 return CommonResult.failed("FAILED");
 }

 @ApiOperation(value = "群组添加管理员")
 @RequestMapping(value = "/addGroupManager", method = RequestMethod.POST)
 @ResponseBody
 public CommonResult<HeAdmin> addGroupManager(
  @RequestParam @ApiParam(value = "群组环信ID", required = true) String groupId,
  @RequestParam @ApiParam(value = "管理员环信id", required = true) String managerId
 ) {
 return heUGroupService.addGroupManager(groupId,managerId);
 }

swagger调用

java实现即时通信的完整步骤分享

token 信息

{“application”:“53e3eeb5-6926-46dd-bc61-4e214342ef7e”,“access_token”:“YWMtXDS-uPG6EeqItFktBQxljAAAAAAAAAAAAAAAAAAAAAFT4-61aSZG3bxhTiFDQu9-AgMAAAF0bSppWwBPGgBXDkgrlvguBLEe966D_LnbgNyNz2OOsTgP4okhQGoOdA”,“expires_in”:5184000}

swagger返回结果

java实现即时通信的完整步骤分享

控制台

java实现即时通信的完整步骤分享

数据库：

java实现即时通信的完整步骤分享

总结

到此这篇关于java实现即时通信的文章就介绍到这了,更多相关java实现即时通信内容请搜索免费资源网以前的文章或继续浏览下面的相关文章希望大家以后多多支持免费资源网！

最新文章 相关文章

Java 封装与继承的陷阱和最佳实践：避免常见的错误

過度封裝：過度限制資料和方法的存取會導致程式碼變得僵化和難以維護。應適度地提供存取，同時保持資料的完整性。 無效封裝：無效封裝會允許未經授權的存取，從而導致資料洩露和安

2024-03-17 01:53:54

Java 线程池实战：提升程序性能与效率

Java 线程池是一种管理线程的机制，有助于提升并发程序的性能和效率。通过集中管理线程资源，线程池可以避免线程创建和销毁的开销，减少内存消耗，并提高代码的可维护性。创建线程

2024-03-17 01:53:33

MapStructPlus 1.4.0 发布，体积更轻量！性能更强！

MapStruct Plus 是 MapStruct 的增强工具，在 Mapstruct 的基础上，实现了自动生成 Mapper 接口的功能，并强化了部分功能，使 Java 类型转换更加便捷、优雅。MapStructPlus官网此次

2024-03-17 01:39:15

JVM内存结构

我们都知道，我们写的Java程序需要先经过编译，生成了.class文件（字节码文件）。然而，计算机并不能直接解释.class文件里面的内容，这时候就需要一个能加载、解释.class文件并且能按.c

2024-03-15 20:58:13

Spring状态机（FSM），让订单状态流转如丝般顺滑

引言在复杂的应用程序设计中，尤其是那些涉及多个状态变迁和业务流程控制的场景，有限状态机（Finite State Machine, FSM）是一种强大而有效的建模工具。Spring框架为此提供了Sprin

2024-03-12 12:05:41

『Java 语法基础』面向对象有哪些特性

面向对象编程（OOP） 是一个将现实世界抽象为一系列对象的编程范式，这些对象通过消息传递机制来互相交流和协作。OOP 的主要特性包括四个基本概念：封装（Encapsulation）、继承（Inherit

2024-03-11 18:44:45

Spring动态定时任务之ScheduledTaskRegistrar

前言​ 在做SpringBoot项目的过程中，有时客户会提出按照指定时间执行一次业务的需求。​ 如果客户需要改动业务的执行时间，即动态地调整定时任务的执行时间，那么可以采用Spring

2024-03-11 18:39:05

分享 Java 开发中常用到的设计模式

前言不知道大家在开发的时候，有没有想过（遇到）这些问题： 大家都是按需要开发，都是一个职级的同事，为什么有些人的思路就很清晰，代码也很整洁、易懂；而自己开发，往往不知道怎么下手设

2024-03-11 18:38:21

Java 实际开发中积累的几个小技巧

目录 前言 一、枚举类的注解 二、RESTful 接口 三、类属性转换 四、Stream 流 五、判空和断言 5.1判空部分 5.2断言部分 文章小结 前言笔者目前从事一线 Java 开发今年

2024-03-11 18:37:52

Java 互联网项目如何防止集合堆内存溢出（一）

目录 前言 一、代码优化 1.1Stream 流自分页 1.2数据库分页 1.3其它思考 二、硬件配置 2.1云服务器配置 三、文章小结 前言OOM 几乎是笔者工作中遇到的线上 bug 中

2024-03-11 18:37:25

日常工作中关于 JSON 转换的经验大全（Java）

目录 前言 一、JSON 回顾 1.1结构形式 二、其它类型 -> JSON相关 2.1 JavaBean 转 JsonObject 2.2 JavaBean 转 Json 字符串 2.3 List 转 JsonArray 2.4 List 转Jso

2024-03-11 18:36:19

从零开始学Spring Boot系列-集成mybatis

在Spring Boot的应用开发中，MyBatis是一个非常流行的持久层框架，它支持定制化SQL、存储过程以及高级映射。在本篇文章中，我们将学习如何在Spring Boot项目中集成MyBatis，以便通

2024-03-11 00:05:13

Jpackage-制作无需预装Java环境的Jar可执行程序

JAR 包要在预装 JRE 环境的系统上执行。如果没有预先安装 JRE 环境，又想直接运行 Java 程序，该怎么办呢？这篇文章我们会先学习如何将 Java 程序打包成一个可执行的 Java JAR 文

2024-03-08 22:43:01

Java 8 Supplier函数式接口介绍及代码样例

介绍供应商接口（Supplier Interface）是 Java 8 引入的 java.util.function 包的一部分，用于在 Java 中实现函数式编程。它表示一个函数，该函数不接收任何参数，但会产生一个类型为

2024-03-08 22:31:58

Java核心之细说泛型

泛型是什么？等你使用java逐渐深入以后会了解或逐步使用到Java泛型。Java 中的泛型是 JDK 5 中引入的功能之一。"Java 泛型 "是一个技术术语，表示一组与定义和使用泛型类型和方

2024-03-08 22:30:26

从零开始搭建Springboot开发环境(Java8+Git+Maven+MySQL+Idea)之一步到位

说明所谓万事开头难，对于初学Java和Springboot框架的小伙伴往往会花不少时间在开发环境搭建上面。究其原因其实还是不熟悉，作为在IT界摸爬滚打数年的老司机，对于各种开发环境搭

2024-03-07 01:02:41

接口 vs. 抽象类：揭开 Java 世界中的神秘面纱

小编带您揭开Java世界中的神秘面纱：接口与抽象类。面向对象编程中，接口与抽象类是常用的概念，但它们的区别与应用场景常让人困惑。通过本文，您将了解到接口与抽象类的定义、特点

2024-03-05 23:25:48

解密MyBatis操作过程：深入探讨ORM框架的关键原理

ORM（Object-Relational Mapping）是一种将对象模型和关系数据库之间的映射的技术，它让我们可以通过面向对象的方式操作数据库，避免了繁琐的SQL语句编写，提高了开发效率。MyBatis是

2024-03-05 23:25:29

Java Lambda 表达式与传统编程范式的比较：函数式编程的优势与劣势

Java Lambda 表达式简介Java Lambda表达式是Java 8引入的函数式编程特性，与传统编程范式相比，具有独特的优势和劣势。通过Lambda表达式，Java可以更简洁地实现函数式编程，提高代

2024-03-05 23:25:10

Lambda表达式在Java中的奇妙之旅：函数式编程的实践指南！

php小编西瓜带你探索Lambda表达式在Java中的奇妙之旅！本文将为您提供函数式编程的实践指南，深入剖析Lambda表达式在Java中的应用场景和优势，帮助您更好地理解和运用这一强大的

2024-03-05 23:24:50

Java JNDI 性能优化技巧：如何提高 Java JNDI 的性能和效率

1. 使用连接池Java JNDI（Java Naming and Directory Interface）是Java中用于访问命名和目录服务的API。在实际开发中，优化Java JNDI性能是非常重要的，可以提高系统的效率和响应

2024-03-05 23:24:31

Java JNDI 与 Spring 集成的秘诀：揭秘 Java JNDI 与 Spring 框架的无缝协作

Java JNDI 与 spring 集成的优势php小编西瓜带你揭秘Java JNDI与Spring框架的无缝协作。Java Naming and Directory Interface（JNDI）是Java平台提供的一种API，可用于访问各种命

2024-03-05 23:24:12

深度探究MyBatis的一对多查询配置：灵活运用关联查询

MyBatis是一个优秀的持久层框架，它不仅简化了数据库操作，还提供了强大的查询功能。在实际开发中，经常会涉及到多表关联查询的情况，而MyBatis通过配置一对多查询可以轻松实现这种

2024-03-05 23:23:51

深入解析MyBatis一对多查询配置：提升SQL语句执行效率

MyBatis是一款非常流行的持久层框架，其灵活的SQL映射和强大的查询功能使得开发人员可以轻松地处理复杂的数据操作。在实际开发中，经常会遇到一对多查询的场景，即一个主体对象对

2024-03-05 23:23:34

一文讲明白Java中线程与进程、并发与并行、同步与异步

写在开头ok，everybody，在过去的两周内，我们大体上讲完了Java的集合，在最后我们探讨了关于HashMap线程不安全的原因，又提出了ConcurrentHashMap这个线程安全的集合解决方案，那么在

2024-03-05 23:09:48

从零开始学Spring Boot系列-前言

在数字化和信息化的时代，Java作为一种成熟、稳定且广泛应用的编程语言，已经成为构建企业级应用的首选。而在Java生态系统中，Spring框架无疑是其中最为耀眼的一颗明星。它提供了

2024-03-03 22:52:19

在 Spring Boot 3.x 中使用 SpringDoc 2 / Swagger V3

SpringDoc V1 只支持到 Spring Boot 2.xspringdoc-openapi v1.7.0 is the latest Open Source release supporting Spring Boot 2.x and 1.x.Spring Boot 3.x 要用 SpringDo

2024-03-01 20:25:28

Java HashMap 详解

HashMapHashMap 继承自 AbstractMap，实现了 Map 接口，基于哈希表实现，元素以键值对的方式存储，允许键和值为 null。因为 key 不允许重复，因此只能有一个键为 null。HashMap 不能

2024-03-01 00:00:17

Java异常处理的20个最佳实践：告别系统崩溃

引言在Java编程中，异常处理是一个至关重要的环节，它不仅涉及到程序的稳定性和安全性，还关系到用户体验和系统资源的合理利用。合理的异常处理能够使得程序在面对不可预知错误时

2024-02-29 23:57:29

阿里面试：Java开发中，应如何避免OOM

Java内存管理：避免OOM的10个实用小技巧引言在Java开发中，OutOfMemoryError（OOM）错误一直是令开发者头疼的问题，也是Java面试中出现核心频率很高的问题。
那么我们究竟怎么样才能

2024-02-29 23:56:58

热点内容

IDEA 2020.3最新永久激活码(免费激活到 2099 年,亲测有效)
2021-02-06
IDEA2020.2.2激活与IntelliJ IDEA2020注册码及IntelliJ全家桶激活码的详细教程(有你足
2020-09-18
解决IDEA 2020.3 lombok失效问题
2020-12-12
springboot yml定义属性,下文中${} 引用说明
2020-05-05
java怎么判断两个集合之间是否有交集
2020-11-20
Java8使用stream实现list中对象属性的合并（去重并求和）
2021-01-09
mybatis-plus 版本不兼容问题的解决
2020-09-25
基于redis setIfAbsent的使用说明
2021-02-06
关于IDEA中spring-cloud-starter-alibaba-nacos-discovery 无法引入问题
2021-03-07
java简短表白代码是什么
2020-09-27
返回顶部
顶部