ym——Android从零开始(27)(山寨版微信-下)(新)

Android开发：山寨版微信实现(下)
最新推荐文章于 2022-05-06 09:56:53 发布
原创 最新推荐文章于 2022-05-06 09:56:53 发布 · 2.4k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文继续介绍山寨版微信的实现，包括聊天功能的设计，消息的处理和存储，以及服务器消息转发的工作原理。内容涉及数据存储的选择、消息来源的区分、不同场景下的消息处理，并提供了一个简单的原理图。

转载请注明本文出自Cym的博客（http://blog.youkuaiyun.com/cym492224103），谢谢支持！


山寨版微信（下）

昨天 我们完成 上线列表刷新。

聊天：

消息：

用户发送：

只需要显示客户端的消息。

一个人可以和多个人聊天。

聊天的内容存放在哪里？数据库  内存  文件

你的数据是那个类来操作。

ThreadClient

HashMap<key,value>  value List<MessageInfo>

消息有两种来源：

1 自己发

2 别人发过来

唯一标示:ip+":"+port

服务器消息的转发工作

处理消息有两种情况：

1 没有聊天，我还在MainActivity

2 在聊天

原理图：

1.png

服务器：

Server： 

public class WeiXinServer {
      
//记录所有的客户端
       publicstatic  List<ThreadClient> list =new ArrayList<ThreadClient>();
      
       /**
        * 启动服务
        * @throws Exception
        */
       publicvoid start() throws Exception{
              final ServerSocket serverSocket = newServerSocket(8809);
              System.out.println(serverSocket.getLocalPort());
              System.out.println(serverSocket.getInetAddress().getHostAddress());
              new Thread(new Runnable() {
                     
                     @Override
                     publicvoid run() {
                            // TODO Auto-generated method stub
                            while(true){
                                   try{
                                          //客户端
                                          Socket socket = serverSocket.accept();
                                          
                                          ThreadClient client = newThreadClient(socket);
                                          client.start();
                                          System.out.println("ip:"+client.ip+",port:"+client.port);
                                          
                                          //通知之前已上线的人
                                          /**
                                           *迭代所有的客户端：发送消息给每个客户端
                                           *c:之前上线的用户
                                           *
                                           */
                                          for(ThreadClient c:list){
                                                 Stringmsg = "refresh@"+client.ip+"@"+client.port;
                                                 c.sendMessage(msg);
                                          }
                                          
                                          //自己的上线之后，也要知道之前上线的人
                                          //client就是自己
                                          for(ThreadClient c:list){
                                                 Stringmsg = "refresh@"+c.ip+"@"+c.port;
                                                 client.sendMessage(msg);
                                          }
                                          
                                          list.add(client);
                                   }catch (Exception e) {
                                          // TODO Auto-generated catch block
                                          e.printStackTrace();
                                   }
                            }
                           
                     }
              }).start();
              } catch (Exception e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }
       }
      
       publicstatic void main(String[] args) {
              // TODO Auto-generated method stub
       start();
       }
}

ThreadClient： 

public class ThreadClient extends Thread {
       //ip地址
       publicString ip;
       //端口号
       publicint port;
       //客户端套接字
       publicSocket socket;
       //输入流
       publicInputStream is;
       //输出流
       publicOutputStream os;
      
       publicPrintWriter pw;
      
       publicBufferedReader br;
      
      
      
      
       publicThreadClient(Socket socket) {
              super();
              try {
                     this.socket= socket;
                     this.ip= socket.getInetAddress().getHostAddress();
                     this.port= socket.getPort();
                     this.is= socket.getInputStream();
                     this.br= new BufferedReader(new InputStreamReader(is));
                     this.os= socket.getOutputStream();
                     
                     this.pw= new PrintWriter(os);
              } catch (Exception e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }
       }
       //发送消息
       publicvoid sendMessage(String msg){
              pw.println(msg);
              pw.flush();
       }
       @Override
       publicvoid run() {
              // TODO Auto-generated method stub
              super.run();
              while(true){
                     try{
                            String message = br.readLine();
                            if(message != null){
                                   System.out.println("服务器得到消息"+message);
                                   StringTokenizertoken = new StringTokenizer(message, "@");
                                   Stringcmd = token.nextToken();
                                   //消息
                                   if("text".equals(cmd)){
                                          String ip1 = token.nextToken();
                                          int port1 =Integer.parseInt(token.nextToken());
                                          String content = token.nextToken();
                                          //查找要发送的目标
                                          //迭代服务器所有的Socket
                                          List<ThreadClient> list =WeiXinServer.list;
                                          for(ThreadClient client:list){
                                                 if(ip1.equals(client.ip)&& port1==client.port){
                                                        //拼接消息text@ip@port@content
                                                        String msg ="text@"+ip+"@"+port+"@"+content;
                                                        client.sendMessage(msg);
                                                        System.out.println(msg);
                                                        break;
                                                 }
                                          }
                                          
                                   }
                            }
                     }catch (Exception e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                     }
              }
       }
}

客户端：Adapter:

public class MyChatMessageAdapter extendsBaseAdapter {
       privateContext context;
       privateList<MessageInfo> infos;
      
       privateLayoutInflater mInflater;
      
       publicMyChatMessageAdapter(Context context, List<MessageInfo> infos) {
              super();
              this.context = context;
              this.infos = infos;
              mInflater = LayoutInflater.from(context);
       }
       @Override
       publicint getCount() {
              // TODO Auto-generated method stub
              return infos.size();
       }
       @Override
       publicObject getItem(int position) {
              // TODO Auto-generated method stub
              return infos.get(position);
       }
       @Override
       publiclong getItemId(int position) {
              // TODO Auto-generated method stub
              return position;
       }
       @Override
       publicView getView(int position, View convertView, ViewGroup parent) {
              // TODO Auto-generated method stub
              View view = null;
              ViewHolder holder = null;
              if(convertView != null){
                     view= convertView;
                     holder= (ViewHolder) view.getTag();
              }else{
                     view= mInflater.inflate(R.layout.chating_item, null);
                     holder= new ViewHolder();
                     holder.tv_message= (TextView) view.findViewById(R.id.tv_message);
                     view.setTag(holder);
              }
              
              MessageInfo info = infos.get(position);
              
              holder.tv_message.setText(info.content);
              return view;
       }
      
       privateclass ViewHolder{
              TextView tv_message;
       }
}

public class MyUserAdapter extends BaseAdapter{
       privateList<UserInfo> infos;
       privateContext context;
       privateLayoutInflater mInflater;
      
       publicMyUserAdapter(List<UserInfo> infos, Context context) {
              super();
              this.infos = infos;
              this.context = context;
              mInflater = LayoutInflater.from(context);
       }
       @Override
       publicint getCount() {
              // TODO Auto-generated method stub
              return infos.size();
       }
       @Override
       publicObject getItem(int position) {
              // TODO Auto-generated method stub
              return infos.get(position);
       }
       @Override
       publiclong getItemId(int position) {
              // TODO Auto-generated method stub
              return position;
       }
       @Override
       publicView getView(int position, View convertView, ViewGroup parent) {
              // TODO Auto-generated method stub
              View view = null;
              ViewHolder holder = null;
              if(convertView != null){
                     view= convertView;
                     holder= (ViewHolder) view.getTag();
              }else{
                     view= mInflater.inflate(R.layout.user_item, null);
                     holder= new ViewHolder();
                     holder.tv_ip= (TextView) view.findViewById(R.id.tv_ip);
                     holder.tv_port= (TextView) view.findViewById(R.id.tv_port);
                     holder.tv_isnew= (TextView) view.findViewById(R.id.tv_isnew);
                     view.setTag(holder);
              }
              
              //得到数据
              UserInfo info = infos.get(position);
              
              holder.tv_ip.setText(info.ip);
              holder.tv_port.setText(info.port+"");
              
              if(info.isNew){
                     holder.tv_isnew.setVisibility(View.VISIBLE);
              }else{
                     holder.tv_isnew.setVisibility(View.INVISIBLE);
              }
              return view;
       }
      
       privateclass ViewHolder{
              TextView tv_ip;
              TextView tv_port;
              TextView tv_isnew;
       }
}

Client: 

public class ThreadClient extends Thread {
       //记录用户的信息
       publicList<UserInfo> userInfos = new ArrayList<UserInfo>();
       //存放所有的消息
       publicHashMap<String,List<MessageInfo>> messages = new HashMap<String,List<MessageInfo>>();
       publicSocket socket;
       publicString ip;
       publicint port;
       publicInputStream is;
       publicOutputStream os;
       publicPrintWriter pw;
       publicBufferedReader br;
      
       publicstatic Context context;
      
      
       privatestatic ThreadClient threadClient;
       public  static ThreadClient  getThreadClient(Context c){
              context = c;
              if(threadClient == null){
                     try{
                            //创建Socket
                            Socket socket = newSocket("192.168.43.143", 8809);
                            threadClient = new ThreadClient(socket);
                            threadClient.start();
                     }catch (Exception e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                     }
                     
              }
              
              return threadClient;
       }
      
       privateThreadClient(Socket socket) {
              super();
              this.socket = socket;
              
              try {
                     this.ip= socket.getInetAddress().getHostAddress();
                     this.port= socket.getPort();
                     this.is= socket.getInputStream();
                     this.br= new BufferedReader(new InputStreamReader(is));
                     this.os= socket.getOutputStream();
                     this.pw= new PrintWriter(os);
              } catch (Exception e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }
       }
       //得到指定用户的信息
       publicList<MessageInfo> getMessages(String key){
              return messages.get(key);
       }
       @Override
       publicvoid run() {
              // TODO Auto-generated method stub
              super.run();
              while(true){
                     try{
                            String message = br.readLine();
                            if(message != null){
                                   StringTokenizertoken = new StringTokenizer(message, "@");
                                   Stringcmd = token.nextToken();
                                   Stringip1 = token.nextToken();
                               int port1 = Integer.parseInt(token.nextToken());
                               //刷新用户的列表
                                   if("refresh".equals(cmd)){
                                          Log.i("i","ip:"+ip1+",port:"+port1);
                                          //刷新列表界面
                                          //发广播
                                          boolean flag =this.ip.equals(ip1)&&this.port == port1;
                                          
                                          Log.i("i","flag:"+flag);
                                          if(!flag){//如果不是自己给自己发送的
                                                 userInfos.add(newUserInfo(ip1, port1));
                                                 Intentintent = new Intent();
                                                 intent.setAction("com.action.jky.MainActivity");
                                                 context.sendBroadcast(intent);
                                                 Log.i("i","已经发出广播");
                                                
                                                 //当有新的用户上线就创建一个新的消息集合
                                                 HashMap<String,List<MessageInfo>> messages = threadClient.messages;
                                                 messages.put(ip1+":"+port1,new ArrayList<MessageInfo>());
                                                
                                          }
                                          
                                   }elseif("text".equals(cmd)){
                                          Log.i("i","得到服务器的消息:"+cmd);
                                          //1 在MainActivity
                                          //2 在ChatingActivity
                                          String name =context.getClass().getName();
                                          Log.i("i", "全类名"+name);
                                          //消息的内容
                                          String content = token.nextToken();
                                          if("com.huaao.weixin.ui.MainActivity".equals(name)){
                                                 Intentintent = new Intent();
                                                 intent.setAction("com.huaao.weixin.ui.MainActivity");
                                                 intent.putExtra("ip",ip1);
                                                 intent.putExtra("port",port1);
                                                 intent.putExtra("content",content);
                                                 context.sendBroadcast(intent);
                                          }elseif("com.huaao.weixin.ui.ChatingActivity".equals(name)){
                                                 Intentintent = new Intent();
                                                 intent.setAction("com.huaao.weixin.ui.ChatingActivity");
                                                 intent.putExtra("ip",ip1);
                                                 intent.putExtra("port",port1);
                                                 intent.putExtra("content",content);
                                                 context.sendBroadcast(intent);
                                          }
                                   }
                            }
                     }catch (Exception e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                     }
              }
       }
      
       //发送消息 目标对象   消息内容
       publicvoid sendMessage(String ip,int port,String message){
              //找到目标对象：告诉服务消息要转发的ip 和　port
              //text@ip@port@message
              String msg ="text@"+ip+"@"+port+"@"+message;
              pw.println(msg);
              pw.flush();
       }
}

Domain: 

public class MessageInfo {
       publicString content;
       publicMessageInfo(String content) {
              super();
              this.content = content;
       }
      
      
}

public class UserInfo {
       publicString ip;
       publicint port;
       publicboolean isNew;//是否有新消息
      
       publicUserInfo(String ip, int port) {
              super();
              this.ip = ip;
              this.port = port;
       }
      
      
}

Ui: 

public class ChatingActivity extendsActivity {
      
       privateTextView tv_title;
       privateListView lv_message;
       privateEditText et_message;
       privateThreadClient threadClient;
       privateString ip;
       privateint port;
       privateString key;
       privateMyChatMessageAdapter adapter;
       @Override
       protectedvoid onCreate(Bundle savedInstanceState) {
              // TODO Auto-generated method stub
              super.onCreate(savedInstanceState);
              
              setContentView(R.layout.chating);
              
              tv_title = (TextView)findViewById(R.id.tv_title);
              lv_message = (ListView)findViewById(R.id.lv_message);
              et_message = (EditText)findViewById(R.id.et_message);
              
              threadClient =ThreadClient.getThreadClient(this);
              
              Intent intent = getIntent();
              ip =intent.getStringExtra("ip");
              port =intent.getIntExtra("port", 0);
              key = ip+":"+port;
              
              tv_title.setText(key);
              
              
              List<MessageInfo> infos =threadClient.getMessages(key);
              adapter = new MyChatMessageAdapter(this,infos);
              lv_message.setAdapter(adapter);
              
              IntentFilter filter = new IntentFilter();
              filter.addAction("com.huaao.weixin.ui.ChatingActivity");
              registerReceiver(new MyReceiver(),filter);
       }
      
      
       privateclass MyReceiver extends BroadcastReceiver{
              @Override
              public void onReceive(Context context,Intent intent) {
                     //TODO Auto-generated method stub
                     //得到消息
                     //把消息添加消息集合
                     //刷新界面
                     
                     Stringip = intent.getStringExtra("ip");
                     intport = intent.getIntExtra("port", 0);
                     Stringcontent = intent.getStringExtra("content");
                     
                     //把消息添加到消息集合
                     List<MessageInfo>messages = threadClient.getMessages(ip+":"+port);
                     messages.add(newMessageInfo(content));
                     
                     adapter.notifyDataSetChanged();
              }
              
       }
      
      
       publicvoid send(View v){
              //得到消息
              //发送消息
              //把消息添加到消息集合
              String message =et_message.getText().toString();
              
              threadClient.sendMessage(ip, port,message);
              
              List<MessageInfo> messages =threadClient.getMessages(key);
              messages.add(new MessageInfo(message));
              
              //刷新消息界面
              adapter.notifyDataSetChanged();
       }
}

public class MainActivity extends Activity{
      
   private ListView lv_user;
       privateMyUserAdapter adapter;
       privateMyRefreshBroadCastReceiver receiver;
       privateThreadClient threadClient;
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.main);
      
       threadClient = ThreadClient.getThreadClient(this);
      
      
       lv_user = (ListView) findViewById(R.id.lv_user);
       List<UserInfo> userInfos = threadClient.userInfos;
       adapter = new MyUserAdapter(userInfos, this);
       lv_user.setAdapter(adapter);
      
       //订阅广播
       receiver = new MyRefreshBroadCastReceiver();
       IntentFilter filter = new IntentFilter();
       //用户上线
       filter.addAction("com.action.jky.MainActivity");
       //有新消息
       filter.addAction("com.huaao.weixin.ui.MainActivity");
       registerReceiver(receiver, filter);
      
       //设置条目的点击事件
       lv_user.setOnItemClickListener(new MyOnItemClickListener());
    }
   
   private class MyOnItemClickListener implements OnItemClickListener{
              @Override
              public voidonItemClick(AdapterView<?> parent, View view, int position,
                            long id) {
                     //TODO Auto-generated method stub
                     UserInfoinfo = (UserInfo) adapter.getItem(position);
                     Intentintent = new Intent(getApplicationContext(),ChatingActivity.class);
                     intent.putExtra("ip",info.ip);
                     intent.putExtra("port",info.port);
                     startActivity(intent);
                     
                     //把新消息隐藏
                     view.findViewById(R.id.tv_isnew).setVisibility(View.INVISIBLE);
              }
           
    }
   
   private class MyRefreshBroadCastReceiver extends BroadcastReceiver{
              @Override
              public void onReceive(Context context,Intent intent) {
                     //TODO Auto-generated method stub
                     Stringaction = intent.getAction();
                     //用户上线
                     if("com.action.jky.MainActivity".equals(action)){
                            adapter.notifyDataSetChanged();
                            Log.i("i","得到通知刷新显示");
                     }elseif("com.huaao.weixin.ui.MainActivity".equals(action)){
                            Log.i("i","有广播到来。。可以出现有新消息");
                            //有新消息
                            String ip =intent.getStringExtra("ip");
                            int port =intent.getIntExtra("port", 0);
                            String content =intent.getStringExtra("content");
                            //把消息添加到消息集合
                            List<MessageInfo> messages =threadClient.getMessages(ip+":"+port);
                            messages.add(new MessageInfo(content));
                           
                            //修改用户有新消息
                            List<UserInfo> userInfos =threadClient.userInfos;
                            for(UserInfo info:userInfos){
                                   if(ip.equals(info.ip)&& port == info.port){
                                          info.isNew = true;
                                          break;
                                   }
                            }
                            adapter.notifyDataSetChanged();
                     }
                     
                     
              }
           
    }
   
}

原创 山寨版微信
zhaoyangjian724的专栏
01-29 1698
use LWP::UserAgent; use URI::Escape; use Net::Ping; use JSON qw(encode_json); use Socket; use Net::SMTP; use LWP; use LWP::Simple; use LWP::UserAgent; use HTTP::Cookies; use HTTP::Headers; use HTTP::R
一款高仿微信的app供大家参考
wblearn的博客
06-15 1万+
上篇我分享的音乐软件源码有一部分童鞋说有问题，我再次说明一下，源码都是我测试好的然后上传的，报错肯定是你们没改编码或者导入你们eclipse方式有误，大家仔细调试后一定没问题。今天晚上有点空闲时间，继续弄了下一款高仿微信的app，现在截图给大家欣赏：        关注我的微博主页
ym——Android从零开始(27)(山寨版微信-上)(新)
陈宇明
08-08 2023
山寨版微信（上） 即时通信 我们使用了Socket编程（套接字编程） 服务器 创建ServerSocket 等待客户端的连接 Socket s =ss.qccpet(); 客户端 Soket s = new Socket(); 原理图： 服务端： /** * 服务器 * * @param arg
IOS开发之微信山寨版
weixin_33871366的博客
09-03 137
　　为了犒劳自己的学习内容，就山寨个微信的视图控制吧。拿着微信，仔细的看了一下，主要用到了TabBarController以及配置TabBarItem, NavigationController以及配置NavigationBarItem， 还用到了我们比较复杂的TableViewController来显示我们的数据。在用到TableView中既有静态的TableView,也有动态的TableVie...
Android 实现微信登录详解
01-20
前言  分享到微信朋友圈的功能早已经有了，但微信登录推出并不久，文档写的也并不是很清楚，这里记录分享一下。  正文  一、准备   注册、认证步骤自己来。微信开放平台：https://open.weixin.qq.com  二、 代码   2.1 唤起微信登录    参考官网文档：资源中心/移动应用开放/接入指南/Android接入指南 private IWXAPI mWeixinAPI; private void loginWithWeixin() { if (mWeixinAPI == null) { mWeixinAPI = WXAPIFactory.creat
ym——android源码大放送（实战开发必备）
热门推荐
陈宇明
08-10 4万+
文件夹 PATH 列表 卷序列号为 000A-8F50 E:. │  javaapk.com文件列表生成工具.bat │  使用说明.txt │  免费下载更多源码.url │  目录列表.txt │   ├─android web应用 │      jqmDemo_static.zip │      jqmMobileDemo-master.zip │      jqmMo
ym—— Android 5.0学习之创建模拟器
陈宇明
11-25 6138
学习Android5.0的提前是你必须要有Android 5.0模拟器或者真机。      两种方式      1.使用Genymotion 安装教程        优点：运行速度很快        缺点：性能消耗高，电脑配置高的话强烈推荐~！ 选择5.0系统 安装直接运 速度杠杠的~！ 2.用Android自带的模拟器     优点：性能消耗低  缺点：
ym—— Android 5.0学习之AnimatedVectorDrawable
陈宇明
12-02 1万+
前言
ym——Android酷炫实用的开源框架（UI框架）
陈宇明
02-09 2万+
转载请注明本文出自Cym的博客（http://blog.youkuaiyun.com/cym492224103），谢谢支持！ 前言 忙碌的工作终于可以停息一段时间了，最近突然有一个想法，就是自己写一个app，所以找了一些合适开源控件，这样更加省时，再此分享给大家，希望能对大家有帮助，此博文介绍的都是UI上面的框架，接下来会有其他的开源框架（如：HTTP框架、DB框架）。 1.Side-M
Android App跳转微信小程序教程
开源世界
05-06 8036
最近，有一个App跳转小程序的需求，参考微信的官方文档，接入还是比较简单的，不过中途遇到了一个坑，所以记录一下。 首先，需要登录微信开放平台 微信开放平台，创建一个移动应用，然后系统会返回一个appid。 需要说明的是，不管是跳转微信小程序还是微信登录、分享，都需要先在微信开放平台注册appId。然后，就可以参考 Android APP拉取小程序的例子，在WebView中调用下面的代码（可以是直接调用，也可以是协议拦截）。 String appId = "wxd930ea5d5a258f4f"; // 填
swing版本山寨微信打飞机
04-21
NULL 博文链接：https://gao-xianglong.iteye.com/blog/1927765
高仿微信界面
05-07
高仿微信界面+自定义跟随手指自适应弹出菜单，这个为Demo，软件界面见https://blog.youkuaiyun.com/fx475870569/article/details/80231774
Android 接入第三方登录 微信登录 微信分享 demo
06-18
Android 接入第三方登录 微信登录。 Android 微信登录，微信分享好友，微信分享朋友圈demo，
android 手把手教你接微信登录功能
zhouguizhi
01-03 7185
android 手把手教你接微信登录功能
android第三方登录之微信登录详情
缘无痕—末世蓝风的博客
09-27 2541
微信的第三方登录详解 根据公司需要，特将APP微信第三方登录予以详解，以共享我这几天的研究成果。 第一步：准备工作 微信登录不同于其他第三方登录，相对来说比较麻烦一点，网上的列子也相对少一点，在微信开放平台注册完应用通过审核之后，得到AppId和AppSecret。就可以进行微信分享等功能，但是要想实现微信登录就必须进行认证。这个认证需要300元。 注册应用的时候签名要用微信官方提供的AP
UVa 156 - Ananagrams
weixin_30859423的博客
11-20 89
又是照着敲的，学习map了，但最后我改成直接用set储存了，省了重新排序的功夫了。 #include<iostream> #include<map> #include<string> #include<set> #include<algorithm> #include<vector> using ...
Android调用微信登陆、分享、支付（第二版本）
安辉
09-16 9900
前言大部分的app都有接入第三方sdk的需求。例如第三方登录需要接入微信、QQ、微博。第三方支付需要接入微信、支付宝、银联。这些我都有使用过，都有使用过他们的sdk，感觉最麻烦的就是微信，不能直接调试，得用正式的签名进行签名才能调试。还有他们官方的demo也是跑不起来的，因为没有签名文件。需要注意的地方也很多。代码实现微信sdk现在支持Android Studio在线引用了，之前都是添加jar的方法
MAC Intellij IDEA 常用快捷键(本人亲自测试过)
陈宇明
10-14 3万+
在mac下idea的常用快捷键如下，下面的快捷键都亲自试用，并有一些和eclipse对比的说明   alt+f7查找在哪里使用 相当于eclipse的ctrl+shift+G command+alt+f7 这个是查找选中的字符在工程中出现的地方，可以不是方法变量类等，这个和上面的有区别的 command＋F7可以查询当前元素在当前文件中的引用，然后按F3可以选择 ，功能基本
HTML简历模板——ym-main的设计与实现
根据提供的信息，我们可以推断出文档标题为“ym：我的简历”，而描述也是相同的“ym：我的简历”，这意味着文档可能是一个HTML格式的个人简历文件，旨在展示某人名为“ym”的个人背景、教育经历、工作经验等信息。...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值