Java开发的应该如何掌握上述相关技术？
一：首先，有这样的一种情况很常见，对于想自学Java开发的人来说，他们
大多数都是非常盲目的，不知道自己改如何入手，很多人在网上找一些视频，然后疯狂的过视频，很快就把一块内容都学完，他们理解的学完了就是视
频看完了，但是让他们动手去做东西却做不出来，而我的理解学完了就是自己能写出东西，所以对于初学者来说一定不能盲目，要有自己的规划，不然
就是浪费时间白忙活。
二：既然是学习Java开发专业技术，我个人的建议是，一定要有一个能指导
你的人，不能都靠自己闭门造车，这样的行为并不聪明，结识一位这方面的人才，时不时去问问人家问题，不然你可能会发现一个小问题能困扰你一天
，**后还不知道是什么原因。
三：学习Java开发技术，不能跟学数学语文一样对待，比较刚接触代码是不
容易记住的，所以要掌握上述的技术，你还要知道学习Java开发技术有哪些“坑”。对于学习方法这块是尤为重要的，怎么学才能让你学完了能记住之
前学的那些，不至于学完了就忘，这个问题值得你学习之前去思考的。
四：根据我多年的学习情况来看，你平时一定要养成好的学习习惯，就说我
自己吧！我就喜欢把自己曾经遇到的问题整理在电脑的日记本上，然后我会搜集一下博客相关的Java技术文章，一些我认为比较有用的网站，以后都能
用的上，这是我个人的学习习惯，相信我，如果你想走的更远，一定要养成习惯。
**后给大家一些详细的学习安排路线：
Java基础：Java基础语法、数组、类与对象、继承与多态、异常、范型、集
合、流与文件、反射、枚举、自动装箱和注解。
数据库：mysql、oracle
Javaweb：HTML与CSS网页开发基础、Java脚本语言、搭建开发环境、JSP基
本语法、JSP内置对象、JavaBean技术、Servlet技术、Ajax技术
框架：Struts2、Hibernate、Spring、SpringMVC、mybatis
一阶段 java基础，我们将学习变量，基本数据类型，进制，转义字符，运
算符，分支语句和循环语句等，以达到训练基础语法和逻辑能力的目的。还有对数组、面向对象和异常处理等。
二阶段 javaWeb，主要是学习Web前端开发基础和框架、Servlet和JSP在Web
后端的应用、Web后端开发相关专题、MVC和分层架构以及项目开发流程及CASE工具的使用等。
三阶段 java框架，像框架整合开发(SSH/SSS)、RESTful架构和移动端接口
设计、第三方接口和在线支付功能、网站安全和Spring Security应用实战、复杂用户交互处理和Spring Web Flow的应用、MyBatis的应用和SSM整合等
技术点都是需要你掌握的。
四阶段 java 云数据，亿级并发架构演进、Linux基础、搭建tomcat环境以
及大数据开发云计算等高级Java教程，是Java技术的高端知识。其中穿插项目实战演练，企业真实项目供学员应用学习，进行知识体系的“二次学习”
。
解决java Socket慢的问题
>
**近本人在业余时间想使用socket写一个访问网页的工具类，用来了解http。
在编写过程中发现，一个大概是5k的图片，用代码去**时候用了足足30秒，但是在浏览器中访问同一个链接的时候只用了3ms，这个中间的差距我实在不能够接收。我是做了什么，我编写的代码这么慢。
经过我在谷歌上搜索发现read()方法当读取完数据之后就开始阻塞，等待返回-1结束，这个等待的过程占到了总时间的99%。可是如果不等待怎么知道结束了？数据不全的话，会造成解析出错。
**查看返回的http头发现，在http返回头中Content-length对应的数字就是消息体的长度，只要**判断获取的长度和头中的长度是一致的，就可以认为数据已经获取完毕了，没有必要等待返回-1来判断是否结束。
**以上的修改，**图片的速度终于上来了，达到了一秒以内。总算不那么慢了，之前那真是要疯了。
附上代码，仅供参考
package com.shxzhlxrr.util.socket;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PRintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
import org.apache.log4j.Logger;
import com.shxzhlxrr.util.StringUtil;
/**
*
* @author zxr
* @date 2017年2月6日 下午6:33:36
*/
public class HttpClient {
/**
* 主机
*/
private String host;
private int port = 80;
private String url;// 主机后面的相对的路径
@SuppressWarnings("unused")
private String baseUrl;// 访问的完整的路径
private String context;
private String protocol;
/**
* 客户端的信息
*/
private String userAgent;
private InputStream contentInputStream;
private byte[] contentData;
private static Logger log = Logger.getLogger(HttpClient.class);
private int status = 200;
private Map<String, Object> header = new HashMap<String, Object>();
public Map<String, Object> getHeader() {
return header;
}
public HttpClient() {
}
/**
* 推荐使用四个参数的构造方法，本构造方法对于url的解析存在一些问题<br/>
* 可能会给你带来一些不必要的问题
*
* @param url
*/
public HttpClient(String url) {
this.baseUrl = url;
this.parseHttpUrl(url);
}
public HttpClient(String host, int port, String url, String protocol) {
this.host = host;
this.port = port;
this.url = url;
this.protocol = protocol;
this.baseUrl = this.protocol "://" this.host ":" this.port "/" this.url;
}
/**
* 获取返回的内容
*
* @return
* @throws Exception
*/
public String getContext() {
return context;
}
/**
* 发送请求
*/
public void send() throws Exception {
if (this.protocol == null) {
this.protocol = "http";
}
if (this.url == null) {
this.url = "/";
}
validateParam();
getHttpContent();
}
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getProtocol() {
return protocol;
}
public void setProtocol(String protocol) {
this.protocol = protocol;
}
public InputStream getContentInputStream() {
return contentInputStream;
}
public byte[] getContentData() {
return contentData;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
public String getUserAgent() {
return userAgent;
}
public void setUserAgent(String userAgent) {
this.userAgent = userAgent;
}
private void getHttpContent() throws Exception {
BufferedReader bf = null;
PrintWriter pw = null;
Socket soc = null;
GZIPInputStream gzin = null;
try {
soc = getSocket();
if (soc.isConnected()) {
pw = new PrintWriter(soc.getOutputStream(), true);// 获取输出流
sendReqMsg(pw);// 发送请求
parseRes(soc);// 解析返回的请求数据
}
} catch (Exception e) {
e.printStackTrace();
throw e;
} finally {
if (bf != null) {
try {
bf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (pw != null) {
pw.close();
}
if (soc != null) {
try {
soc.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (gzin != null) {
gzin.close();
}
}
}
/**
* 获取访问的socket
*
* @return
* @throws IOException
* @throws NoSuchAlgorithmException
* @throws UnknownHostException
* @throws KeyManagementException
*/
private Socket getSocket()
throws KeyManagementException, UnknownHostException, NoSuchAlgorithmException, IOException {
Socket soc = null;
if ("https".equals(this.protocol)) {
soc = getHttpsSocket();
} else {
soc = new Socket(InetAddress.getByName(this.host), this.port);
}
return soc;
}
/**
* 获取httpssocket
*
* @return
* @throws UnknownHostException
* @throws IOException
* @throws NoSuchAlgorithmException
* @throws KeyManagementException
*/
private Socket getHttpsSocket()
throws UnknownHostException, IOException, NoSuchAlgorithmException, KeyManagementException {
X509TrustManager xtm;
try {
xtm = new Java2000TrustManager();
TrustManager mytm[] = { xtm };
// 得到上下文
SSLContext ctx = SSLContext.getInstance("SSL", "SunJSSE");
// SSLContext ctx = SSLContext.getInstance("TLS");
// 初始化
ctx.init(null, mytm, new java.security.SecureRandom());
// ctx.init(null, null, null);
// 获得工厂
SSLSocketFactory factory = ctx.getSocketFactory();
// 从工厂获得Socket连接
Socket socket = factory.createSocket(host, port);
return socket;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 解析返回的数据
*/
private void parseRes(Socket soc) throws IOException {
long start = System.currentTimeMillis();
InputStream in = soc.getInputStream();
byte[] buf = new byte[1024 * 200];
int isClose = 0;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
List<String> titles = new ArrayList<String>();
while ((isClose = in.read()) != -1) {
baos.write(isClose);
if ( \n == isClose) {
String str = new String(baos.toByteArray());
titles.add(str);
baos.reset();
if (StringUtil.isNull(str)) {// 这个时候表示到了空行。
parseHeader(titles);
break;
}
}
}
long end = System.currentTimeMillis();
int count = 0;
log.debug("[解析图片的头]：" ((end - start) / 1000));
log.debug("[返回的消息的头]：" this.header);
if ("chunked".equals(this.header.get("Transfer-Encoding"))) {
baos = parseChunk(in);
} else {
int content_length = Integer.valueOf(String.valueOf(this.header.get("Content-Length")));
int countNum = 0;
while ((count = in.read(buf)) != -1) {
baos.write(buf, 0, count);
countNum = countNum count;
end = System.currentTimeMillis();
log.debug("[解析内容]：" ((end - start) / 1000));
if (content_length == countNum) {
break;
}
}
}
end = System.currentTimeMillis();
log.debug("[解析消息的主体]：" ((end - start) / 1000));
byte[] contentBuf = baos.toByteArray();
if ("gzip".equals(this.header.get("Content-Encoding"))) {// 当是gzip压缩的时候，进行解压
contentBuf = ungzip(contentBuf);
}
this.context = new String(contentBuf);
this.contentData = contentBuf;
this.contentInputStream = new ByteArrayInputStream(this.contentData);
// }
end = System.currentTimeMillis();
log.debug("[解析完毕]：" ((end - start) / 1000));
}
/**
* 解析chunk编码的数据
*
* @param in
* @return
*/
@SuppressWarnings("resource")
private ByteArrayOutputStream parseChunk(InputStream in) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
try {
out = parseChunk(out, in);
} catch (Exception e) {
e.printStackTrace();
}
return out;
}
/**
* 解析chunk编码的数据
*
* @param out
* @param in
* @return
* @throws IOException
*/
public ByteArrayOutputStream parseChunk(ByteArrayOutputStream out, InputStream in) throws IOException {
ByteArrayOutputStream temp = new ByteArrayOutputStream();
int ch = 0;
while ((ch = in.read()) != -1) {
if ( \r == ch) {
continue;
}
if ( \n == ch) {
break;
}
temp.write(ch);
}
String tempStr = new String(temp.toByteArray());
if (!"".equals(tempStr.trim())) {
int count = Integer.parseInt(new String(temp.toByteArray()).trim(), 16);
if (count == 0) {
return out;
}
int num = 0;
while (num < count) {
int chr = in.read();
out.write(chr);
num ;
}
}
out = parseChunk(out, in);
return out;
}
/**
* 校验基本的数据不能为空
*/
private void validateParam() {
assertNotNull("端口号不能为空", this.port);
assertNotNull("主机不能为空", this.host);
assertNotNull("访问的链接不能为空", this.url);
assertNotNull("访问的协议不能为空", this.protocol);
assertTrue("请设置协议为 http 或 https ", Pattern.compile("http[s]*").matcher(this.protocol).find());
}
/**
* 发送请求信息
*/
private void sendReqMsg(PrintWriter pw) {
pw.println("GET " this.url " HTTP/1.1");
pw.println("Accept:text/html,image/webp,*/*;q=0.8");
pw.println("Accept-Encoding:gzip, deflate, sdch, br");
pw.println("Accept-Language:zh-CN,zh;q=0.8");
pw.println("Connection:keep-alive");
if ("http".equals(this.protocol)) {
pw.println("Host:" this.host ":" this.port);
} else {
pw.println("Host:" this.host);
}
if (this.userAgent != null) {
pw.println(this.userAgent);
} else {
this.userAgent = "User-Agent:Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.71 Safari/537.36";
pw.println(this.userAgent);
}
pw.println("\r\n");
}
/**
* 用来解析返回的数据的**行
*
* @param header
*/
private void parseHeader(List<String> titles) {
String header = titles.get(0);
String[] haaders = header.split(" ");
this.header.put("protocol", haaders[0].trim());
this.header.put("status", haaders[1].trim());
this.status = Integer.valueOf(haaders[1].trim());
titles.remove(0);
for (String title : titles) {
if (StringUtil.isNull(title)) {
continue;
}
String key = title.substring(0, title.indexOf(":"));
String value = title.substring(title.indexOf(":") 1);
this.header.put(key.trim(), value.trim());
}
log.debug(this.header);
}
/**
* 从一个url链接中解析出 host，端口，url，protocol 等
*
* @param url
*/
private void parseHttpUrl(String url) {
// TODO 校验url是否是正确的
String protocol = "http";
if (url.startsWith("https")) {
protocol = "https";
}
url = url.substring(url.indexOf("//") 2);
String host = url;
if (url.indexOf("/") < 0) {
url = "/";
} else {
host = url.substring(0, url.indexOf("/"));
url = url.substring(url.indexOf("/"));
}
int port = 80;
if ("https".equals(protocol)) {
port = 443;
}
if (host.contains(":")) {
port = Integer.valueOf(host.substring(host.indexOf(":") 1));
host = host.substring(0, host.indexOf(":"));
}
this.host = host;
this.port = port;
this.url = url;
this.protocol = protocol;
}
/**
* 将gzip压缩的字节数据进行解压
*
* @param gzipbuf
* @return
* @throws IOException
*/
public byte[] ungzip(byte[] gzipbuf) throws IOException {
GZIPInputStream gzin = new GZIPInputStream(new ByteArrayInputStream(gzipbuf));
BufferedInputStream bufis = new BufferedInputStream(gzin);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buf = new byte[1024];
int count = 0;
while ((count = bufis.read(buf)) != -1) {
baos.write(buf, 0, count);
}
return baos.toByteArray();
}
}
class Java200TrustManager implements X509TrustManager {
X509TrustManager sunJSSEX509TrustManager;
Java200TrustManager() throws Exception {
// 这里可以进行证书的初始化操作，使用的是jdk自带的证书
String cerPath = "cer/cacerts";
InputStream in = getClass().getClassLoader().getResourceAsStream(cerPath);
KeyStore ks = KeyStore.getInstance("JKS");
ks.load(in, "changeit".toCharArray());
TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509", "SunJSSE");
tmf.init(ks);
TrustManager tms[] = tmf.getTrustManagers();
for (int i = 0; i < tms.length; i ) {
if (tms[i] instanceof X509TrustManager) {
sunJSSEX509TrustManager = (X509TrustManager) tms[i];
return;
}
}
throw new Exception("Couldn t initialize");
}
// 检查客户端的可信任状态
public void checkClientTrusted(X509Certificate chain[], String authType) throws CertificateException {
// System.out.println("检查客户端的可信任状态...");
// System.out.println("checkClientTrusted-------------------");
// System.out.println("chain:" chain);
// System.out.println("authType:" authType);
sunJSSEX509TrustManager.checkClientTrusted(chain, authType);
}
// 检查服务器的可信任状态
public void checkServerTrusted(X509Certificate chain[], String authType) throws CertificateException {
// System.out.println("检查服务器的可信任状态");
sunJSSEX509TrustManager.checkServerTrusted(chain, authType);
// System.out.println("checkServerTrusted==========");
// System.out.println("chain:" chain);
// System.out.println("authType:" authType);
}
// 返回接受的发行商数组
public X509Certificate[] getAcceptedIssuers() {
// System.out.println("获取接受的发行商数组...");
return sunJSSEX509TrustManager.getAcceptedIssuers();
// return null;
}
}
相关推荐：
苏州JAVA培训 苏州JAVA培训班 苏州JAVA培训机构
