技术点对点

线程


1、实例化
实现Runnable
Tread thread = new Thread(runnable);
thread.start();

继承Thread
TestThread extends Thread


2、线程主要方法
currentThread：静态方法，获取当前线程；
sleep：静态方法，在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）；
yield：静态方法，使正在执行的线程进入可执行状态队列，让其他同优先级的线程执行；
join：使调用该方法的线程在此之前执行完毕，也就是等待调用该方法的线程执行完毕后再往下继续执行；
interrupt：线程中断，是终止，不是死亡状态；
wait：导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，
   释放CPU的执行权，释放锁；
notify：
setDaemon(true)：守护线程；

3、sleep与yield的区别
a、sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；yield()只是使当前线程重新回到可执行状态，
所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
b、sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；
yield()只能使同优先级的线程有执行的机会。




线程状态：New（新生）、Runnable（可运行）、running（运行）、Blocked（被阻塞）、Dead（死亡）；


以下状态线程会被阻塞：sleep、I/O操作、锁、suspend（挂起，此方法已过时，resume唤醒）；


ReentrantLock：锁，lock()、unlock()、newCondition()、await()、signaAll()


synchronized：wait、notifyAll；




***************************************************************************************
反射


Class cls = Test.getClass();
Class cls = Class.forName("class str");
Test test = (Test)cls.newInstance();


Constructor[] ctor = xxx.getDeclaredConstructors();
ctor.getName();
ctor.getParameterTypes();


Method[] method = xxx.getDeclaredMethods();
method.getName();
method.getReturnType();
method.getParameterTypes();
method.getModifiers();返回修饰符


Field[] fields = xxx.getDeclareFields();
field.getName();
field.getType();
field.getModifiers();返回修饰符


动态代理
public class ProxyTest implements InvocationHandler{
private Object target;

public Object bind(Object target){
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}

@Override
public Object invoke(Object obj, Method method, Object[] arg)
throws Throwable {
return method.invoke(obj, arg);
}


}




************************************************************************************
JTA/JTS


事务的4个特性：
原子性：事务中的各个操作不可分割。
一致性：违反约束则回滚到原来状态。
隔离性：并发访问，不破坏数据的正确性和完整性。
持久性：数据的固化。


数据操作过程中可能出现的三种不确定情况：
脏读取：一个事务读取了另一个并行事务未提交的数据。
不可重复读：一个事务再次读取之前曾读取过的数据时，发现该数据已经被另一个已提交的事务修改。
虚读/幻读：一个事务重新执行一个查询，返回一套符合查询条件的记录，但这些记录中包含了因为其他最近提交
的事务而产生的新记录。




为了避免以上三种情况的出现，标准sql规范中，定义了4个事务隔离等级：
Read Uncommitted：最低等级的事务隔离，它仅仅保证了读取过程中不会读取到非法数据。这种隔离
等级下，上述3种不确定情况均有可能发生。
Read Commited：此级别的事务隔离保证了一个事务不会读到另一个并行事务已修改但未提交的数据，
也就是说，此等级的事务级别避免了脏读取。
此事务隔离等级是大多数主流数据库的默认事务等级，同时也使用于大多数系统。
Repeatable Read：此级别的事务隔离避免了脏读取和不可重复读现象的出现，这意味着，一个事务不
可能更新已经由另一个事务读取但未提交（回滚）的数据。
一般而言，此级事务应用并不广泛，它并不能完全保证数据的合法性（可能出现虚读），同时也带来了更多的
性能损失，如果当前数据库由应用所独享，那么我们可以考虑通过乐观锁达到同样的目的。
Serializable
最高级别的事务隔离，也提供了最严格的隔离机制。上面3种不确定情况都被规避。这个级别将模拟事务的串行
执行，逻辑上如同所有事务都处于一个执行队列，依次串行执行，而非并行执行。
此事务性能消耗高昂，如果确实需要，我们可以通过一些其他的策略加以实现，如悲观锁。


传播行为：
PROPAGATION_MANDATORY：方法必需在一个现存的事务中进行，否则丢出异常；
PROPAGATION_NESTED：在一个嵌入的事务中进行，如果不是，丢出异常；
PROPAGATION_NEVER：不应在事务中进行，如果有就丢出异常；
PROPAGATION_SUPPORTS：支持现在的事务，如果没有就以非事务的方式执行；
PROPAGATION_NOT_SUPPORTED：不应在事务中进行，如果有就暂停现存的事务；
PROPAGATION_REQUIRED：支持现在的事务，如果没有就建立一个新的事务；
PROPAGATION_REQUIRES_NEW：建立一个新的事务，如果现存一个事务就暂停它；
 
 
**********************************************************************************


TCP
Socket(String host, String port);
getInputStream()/getOutputStream();


ServerSocket(String port);  
Socket socekt = serverSocket.accept();


while(true){
Socket socket = serverSocket.accept();
Runnable runnable = new TreadedEchoHandler(socket);
}


URL url = new URL(String urlStr);
InputStream inputStream = url.openStream();


URLConnection urlConnection = url.openConnection();
urlConnection.connect();


urlConnection.setDoOutput(true);


base64Encode(str);//将字节流编码成可打印的ASCII字符流；


URLEncoder.encode(String str, String encoding);//采用指定的字符编码模式对字符串进行编码；
URLDecoder.decode(String, String encoding);//采用指定的字符编码模式对字符串进行解码；


SocketChannel channel = SocketChannel.open(new InetSocketAddress(host, port));//可中断套接字
OutputStream outStream = Channels.newOutputStream(channel);
Scanner in = new Scanner(channel);


socket.shutdownOutput();//半关闭


InetAddress address = InetAddress.getByName("");




***************************************************************************
XML


DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); 
DocumentBuilder builder = factory.newDocumentBuilder(); 
Document document = builder.newDocument(); 
Element root = this.document.createElement("employees"); 
this.document.appendChild(root); 


DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); 
DocumentBuilder db = dbf.newDocumentBuilder(); 
Document document = db.parse(fileName);
document.normalize();
NodeList employees = document.getChildNodes(); 
for (int i = 0; i < employees.getLength(); i++) { 
Node employee = employees.item(i); 
...
}




*****************************************************************************


Ajax


回调函数
beforeSend：在发送请求之前调用，并且传入一个XMLHttpRequest作为参数；
error：在请求出错时，传入XMLHttpRequest对象，描述错误类型的字符串以及一个异常对象（如果有的话）；
dataFilter：在请求成功后调用。传入返回的数据以及"dataType"参数的值。并且必须返回新的数据（可能是处理过的）
传递给success回调函数；
success：当请求之后调用。传入返回的数据，以及包含成功代码的字符串；
complete：当请求完成后调用这个函数，无论成功或失败；传入XMLHttpRequest对象，以及一个包含成功或错误代码的字符串；


选项
async：是否异步；
contentType：发送信息到服务器时内容编码类型；
context：this对象；
data：内容参数；
dataType：预期服务器返回的数据类型；xml、html、script、json、jsonp、text；
type：方法类型，GET、POST等；
url：请求rul；

例子：
var xmlDocument = [create xml document];
$.ajax({
type: "POST",
 url: "page.php",
 processData: false,//不能转换data格式
 data: xmlDocument,
 success: handleResponse
});


载入远程HTML文件代码并插入至DOM中
$("#id").load(url, [data], [callback])：


应用方法
$.get(url, [data], [callback], [type])
$.getJSON(url, [data], [callback]);
$.getScript(url, [data], [callback]);
$.post(url, [data], [callback], [type]);


Ajax事件
ajaxComplete(callback);
ajaxError(callback);
ajaxSend(callback);//请求开始前
ajaxStart(callback);//请求开始时
ajaxStop(callback);//请求结束时
ajaxSuccess(callback);//请求成功

例子：请求完成时执行函数，
$("#msg").ajaxComplete(function(event,request, settings){
 $(this).append("<li>请求完成.</li>");
});




*****************************************************************************


WebService


Apache CXF
Web服务标准：JAX-WS，java API for XML Web Service；


1、代码方式开发WebService


@WebService
public interface HelloWorld{
String sayHi(@WebParam(name="text")String text);
String sayHiToUser(User user);
String[] sayHiToUserList(List<User> userList);
}

@WebService(endpointInterface="com.demo.HelloWorld", serviceName="HelloWorld")
public class HelloWorldImpl implements HelloWorld{
Map<Integer, User> users = new LinkedHashMap<Integer, User>();

public String sayHi(String text){
return "hello," + text;
}

public String sayHiToUser(User user){
users.put(users.size()+1, user);
return "hello" + user.getName();
}

public String[] sayHiToUserList(List<User> userList){
String[] result = new String[userList.size()];
int i = 0;
for(User user:userList){
result[i] = "hello" + user.getName();
i++;
}
return result;
}
}

public class WebServiceApp{
public static void main(String[] args){
System.out.println("web service start");
HelloWorldImpl helloWorldImpl = new HelloWorldImpl();
String address = "http://localhost:8080/helloWorld";
Endpoint.publish(address, helloWorldImpl);
System.out.println("web service started");
}
}

run webServiceApp.java类来启动服务。访问http://localhost:8080/helloWorld?wsdl
查看是否显示wsdl；

客户端访问服务
public class HelloWorldClent{
public static void main(String[] args){
JaxWsProxyFactoryBean jaxFactory = new JaxWsProxyFactoryBean();
jaxFactory.setServiceClass(HelloWorld.class);
jaxFactory.setAddress("http://localhost:8080/helloWorld");
HelloWorld helloWorld = (HelloWorld)jaxFactory.create();
User user = new User();
user.setName("Tony");
user.setDescription("test");
System.out.println(helloWorld.sayHiToUser(user));
}
}

run WebServiceApp.java类来启动服务，然后run HelloWorldClient.java来访问服务；

2、集成到Spring中

在web.xml中加入
<servlet>
<servlet-name>CXFServlet</servlet-name>
<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>CXFServlet</servlet-name>
<url-pattern>/webservice/*</url-pattern>
</servlet-mapping>

在applicationContext.xml中加入：
<beans>
<import resource="classpath:META-INF/cxf/cxf.xml"/>
<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml"/>
<import resource="classpath:META-INF/cxf/cxf-servlet.xml"/>

<jaxws:endpoint id="helloWorld" implementor="com.demo.HelloWorldImpl" address="/helloWorld"/>

<bean id="client" factory-bean="com.demo.HelloWorld" factory-method="create"/>

<bean id="clientFactory" class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean">
<property name="serviceClass" value="com.demo.HelloWorld"/>
<property name="address" value="http://localhost:8080/s/webservice/helloworld"/>
</bean>
</beans>


客户端
public class HelloWorldClient{
HelloWorld client = (HelloWorld)context.getBean("client");
User user1 = new User();
user1.setName("Tony");
user1.setDescription("test");
User user2 = new User();
user2.setName("freeman");
user2.setDescription("test");

List<User> userList = new ArrayList<User>();
userList.add(user1);
userList.add(user2);

String[] res = client.sayHiToUserList(userList);
System.out.println(res[0]);
System.out.println(res[1]);
}

发布工程，启动web服务器
访问http://localhost:8080/s/webservice/helloWorld?wsdl  查看是否显示 wsdl 。
run HelloWorldClient.java访问服务；






********************************************************************************************


计算机网络


OSI：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层；
TCP/IP：网络接口层、互联层、传输层、应用层；


1、物理层
建立、维护和取消物理连接，传输比特流，如光纤、同轴电缆、双绞线、中继器和集线器；


2、数据链路层
在物理层上建立、撤销、标识逻辑链接和链路复用以及差错校验等功能。通过使用接收系统的硬件地址
或物理地址来寻址；将比特信息封装成数据帧，如网桥、交换机、网卡；

3、网络层
基于网络层地址（IP地址）进行不同网络系统间的路径选择，分割和重新组合数据包packet，如路由器；

4、传输层
用一个寻址机制来标识一个特定的应用程序（端口号），数据组织成数据段；TCP、UDP等；

5、会话层
建立、管理和终止会话；

6、表示层
数据表示、数据安全、数据压缩

7、应用层
网络服务与使用者应用程序间的一个接口；Telnet、FTP、HTTP、SNMP、DNS等；