Linux教程網 >> Linux編程 >> Linux編程 >> Spring的IOC和AOP之深剖

Spring的IOC和AOP之深剖

日期：2017/3/1 9:11:11 编辑：Linux編程

我們首先要知道，用Spring主要是兩件事：

1、開發Bean；2、配置Bean。對於Spring框架來說，它要做的，就是根據配置文件來創建bean實例，並調用bean實例的方法完成“依賴注入”。

Spring框架的作用是什麼？有什麼優點？

1.降低了組件之間的耦合性，實現了軟件各層之間的解耦
2.可以使用容易提供的眾多服務，如事務管理，消息服務等
3.容器提供單例模式支持
4.容器提供了AOP技術，利用它很容易實現如權限攔截，運行期監控等功能
5.容器提供了眾多的輔助類，能加快應用的開發
6.spring對於主流的應用框架提供了集成支持，如hibernate，JPA，Struts等
7.spring屬於低侵入式設計，代碼的污染極低
8.獨立於各種應用服務器
9.spring的DI機制降低了業務對象替換的復雜性
10.Spring的高度開放性，並不強制應用完全依賴於Spring，開發者可以自由選擇spring的部分或全部

什麼是DI機制？

依賴注入（Dependecy Injection）和控制反轉（Inversion of Control）是同一個概念，具體的講：當某個角色
需要另外一個角色協助的時候，在傳統的程序設計過程中，通常由調用者來創建被調用者的實例。但在spring中
創建被調用者的工作不再由調用者來完成，因此稱為控制反轉。創建被調用者的工作由spring來完成，然後注入調用者
因此也稱為依賴注入。是面向編程中的一種設計理念，用來減低程序代碼之間的耦合度。
spring以動態靈活的方式來管理對象，注入的兩種方式，設置注入和構造注入。
設置注入的優點：直觀，自然
構造注入的優點：可以在構造器中決定依賴關系的順序。

現在我們用例子來具體理解它

1.Spring提供的幾種依賴注入(控制反轉)的方式

1）setter（設置）注入
2）構造器注入
3）接口注入

但是，我們要了解什麼是依賴？

我們所知道的依賴：

①依靠別人或事物而不能自立或自給；②指各個事物或現象互為條件而不可分離。

專業解析：依賴，在代碼中一般指通過局部變量，方法參數，返回值等建立的對於其他對象的調用關系。

例如:在A類的方法中，實例化了B類的對象並調用其方法以完成特定的功能，我們就說A類依賴於B類。

Spring設置注入和構造注入的區別

設置注入是先通過調用無參構造器創建一個bean實例，然後調用對應的setter方法注入依賴關系；而構造注入則直接調用有參數的構造器，當bean實例創建完成後，已經完成了依賴關系的注入。另外這兩種依賴注入的方式，並沒有絕對的好壞，只是適應的場景有所不同。

setter方法注入：

Entity

public class Happy {
private String happyInfo;

public void happy(){
System.out.println(happyInfo);
}

public String getHappyInfo() {
return happyInfo;
}

public void setHappyInfo(String happyInfo) {
this.happyInfo = happyInfo;
}

applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="happy" class="cn.wgy.day_01.entity.Happy">



<property name="happyInfo" value="中秋快樂"></property>

</bean>
</beans>

test類

public static void main(String[] args) {
//獲取上下文對象
//ApplicationContext context2=new FileSystemXmlApplicationContext("applicationContext.xml");

//BeanFactory beanf=new FileSystemXmlApplicationContext("applicationContext.xml");

ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
// Object getBean(String name) throws BeansException;
Happy happy = (Happy) context.getBean("happy");

happy.happy();
}
}

注意:ApplicationContext ,其實還有BeauFactory也可以，那麼它們兩的區別是啥呢？請看下面

BeanFacotry是spring中比較原始的Factory。如XMLBeanFactory就是一種典型的BeanFactory。原始的BeanFactory無法支持spring的許多插件，如AOP功能、Web應用等。
ApplicationContext接口,它由BeanFactory接口派生而來，因而提供BeanFactory所有的功能。ApplicationContext以一種更向面向框架的方式工作以及對上下文進行分層和實現繼承，ApplicationContext包還提供了以下的功能：
01.MessageSource, 提供國際化的消息訪問
02. 資源訪問，如URL和文件
03.事件傳播
04. 載入多個（有繼承關系）上下文，使得每一個上下文都專注於一個特定的層次，比如應用的web層
1.利用MessageSource進行國際化
BeanFactory是不支持國際化功能的，因為BeanFactory沒有擴展Spring中MessageResource接口。相反，由於ApplicationContext擴展了MessageResource接口，因而具有消息處理的能力(i18N)

2.強大的事件機制(Event)
基本上牽涉到事件(Event)方面的設計，就離不開觀察者模式。不明白觀察者模式的朋友，最好上網了解下。因為，這種模式在java開發中是比較常用的，又是比較重要的。
ApplicationContext的事件機制主要通過ApplicationEvent和ApplicationListener這兩個接口來提供的，和java swing中的事件機制一樣。即當ApplicationContext中發布一個事件的時，所有擴展了ApplicationListener的Bean都將會接受到這個事件，並進行相應的處理。

Spring提供了部分內置事件，主要有以下幾種：
ContextRefreshedEvent ：ApplicationContext發送該事件時，表示該容器中所有的Bean都已經被裝載完成，此ApplicationContext已就緒可用
ContextStartedEvent：生命周期 beans的啟動信號
ContextStoppedEvent: 生命周期 beans的停止信號
ContextClosedEvent：ApplicationContext關閉事件，則context不能刷新和重啟，從而所有的singleton bean全部銷毀(因為singleton bean是存在容器緩存中的)

雖然，spring提供了許多內置事件，但用戶也可根據自己需要來擴展spriong中的事物。注意，要擴展的事件都要實現ApplicationEvent接口。

3.底層資源的訪問
ApplicationContext擴展了ResourceLoader(資源加載器)接口，從而可以用來加載多個Resource，而BeanFactory是沒有擴展ResourceLoader

4.對Web應用的支持
與BeanFactory通常以編程的方式被創建不同的是，ApplicationContext能以聲明的方式創建，如使用ContextLoader。當然你也可以使用ApplicationContext的實現之一來以編程的方式創建ApplicationContext實例。

ContextLoader有兩個實現：ContextLoaderListener和ContextLoaderServlet。它們兩個有著同樣的功能，除了listener不能在Servlet 2.2兼容的容器中使用。自從Servelt 2.4規范，listener被要求在web應用啟動後初始化。很多2.3兼容的容器已經實現了這個特性。使用哪一個取決於你自己，但是如果所有的條件都一樣，你大概會更喜歡ContextLoaderListener；關於兼容方面的更多信息可以參照ContextLoaderServlet的JavaDoc。

這個listener需要檢查contextConfigLocation參數。如果不存在的話，它將默認使用/WEB-INF/applicationContext.xml。如果它存在，它就會用預先定義的分隔符（逗號，分號和空格）分開分割字符串，並將這些值作為應用上下文將要搜索的位置。ContextLoaderServlet可以用來替換ContextLoaderListener。這個servlet像listener那樣使用contextConfigLocation參數。

5.其它區別
1).BeanFactroy采用的是延遲加載形式來注入Bean的，即只有在使用到某個Bean時(調用getBean())，才對該Bean進行加載實例化，這樣，我們就不能發現一些存在的spring的配置問題。而ApplicationContext則相反，它是在容器啟動時，一次性創建了所有的Bean。這樣，在容器啟動時，我們就可以發現Spring中存在的配置錯誤。

2).BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但兩者之間的區別是：BeanFactory需要手動注冊，而ApplicationContext則是自動注冊

構造器注入：

其他的代碼都差不多，這裡我就直接寫applicationContext.xml

">

<bean id="user1" class="cn.wgy.day01.entity.User">
<constructor-arg index="0" type="java.lang.String" value="Promise"/>
<constructor-arg index="1" type="java.lang.String" value="[email protected]"/>
</bean>
</beans>

多種方式實現依賴注入

設值注入：普通屬性，域屬性（JavaBean屬性）

構造注入：普通屬性，域屬性（JavaBean屬性）

命名空間p注入：普通屬性，域屬性（JavaBean屬性）

我們使用前要先要在Spring配置文件中引入p命名空間：xmlns:p="http://www.springframework.org/schema/p"

注入不同數據類型：

1.注入直接量

2.引用bean組件

3.使用內部bean

4.注入集合類型的屬性

5.注入null和空字符串

<bean id="user" class="cn.wgy.day01.entity.User" p:username="Promise"></bean>

<bean id="dao" class="cn.wgy.day01.dao.impl.UserDao" />

<bean id="biz" class="cn.wgy.day01.biz.impl.UserBiz" p:dao-ref="dao"></bean>


<bean id="list" class="cn.wgy.day01.entity.CollectionBean">
<property name="names">
<list>
<value>Promise</value>
<value>Promise2</value>
</list>
</property>
</bean>

<bean id="set" class="cn.wgy.day01.entity.CollectionBean">
<property name="address">
<set>
<value>北京</value>
<value>上海</value>
</set>
</property>
</bean>

<bean id="map" class="cn.wgy.day01.entity.CollectionBean">
<property name="map">
<map>
<entry key="nh">
<key>
<value>1</value>
</key>
<value>12</value>

</entry>
<entry>
<key>
<value>2</value>
</key>
<value>20</value>

</entry>
</map>
</property>
</bean>

現在我們來理解AOP

什麼是AOP？

面向切面編程（AOP）完善spring的依賴注入（DI），面向切面編程在spring中主要表現為兩個方面
1.面向切面編程提供聲明式事務管理
2.spring支持用戶自定義的切面

面向切面編程（aop）是對面向對象編程（oop）的補充，
面向對象編程將程序分解成各個層次的對象，面向切面編程將程序運行過程分解成各個切面。
AOP從程序運行角度考慮程序的結構，提取業務處理過程的切面，oop是靜態的抽象，aop是動態的抽象，
是對應用執行過程中的步驟進行抽象，，從而獲得步驟之間的邏輯劃分。

aop框架具有的兩個特征：
1.各個步驟之間的良好隔離性
2.源代碼無關性

話不多說，我們直接來代碼，加強理解

我們先看一個簡單的例子：Spring AOP實現日志的輸出，即後置增強和前置增強

我們看看代碼

aop包下

我們要實現AfterReturningAdvice 接口

public class LoggerAfter implements AfterReturningAdvice {
//save()之後執行它
public void afterReturning(Object returnValue, Method method, Object[] arguments ,
Object target) throws Throwable {
System.out.println("===========後置增強代碼==========");

}

}

前置，我們要實現MethodBeforeAdvice接口

*/
public class LoggerBefore implements MethodBeforeAdvice {
//獲取日志對象
private static final Logger log = Logger.getLogger(LoggerBefore.class);
//save()之前執行它
public void before(Method method, Object[] arguments, Object target)
throws Throwable {
log.info("==========前置增強代碼==========");

}

}

實現類：

biz:

public class UserBiz implements IUserBiz {
//實例化所依賴的UserDao對象，植入接口對象
private IDao dao;
public void save2(User user) {
//調用UserDao的方法保存信息
dao.save(user);
}
//dao 屬性的setter訪問器，會被Spring調用，實現設值注入
public IDao getDao() {
return dao;
}
public void setDao(IDao dao) {
this.dao = dao;
}

dao:

public class UserDao implements IDao {
/**
* 保存用戶信息的方法
* @param user
*/
public void save(User user) {
System.out.println("save success!");
}

}

src下的applicationContext.xml

<bean id="dao" class="cn.wgy.day01.dao.impl.UserDao"/>
<bean id="biz" class="cn.wgy.day01.biz.impl.UserBiz">
<property name="dao" ref="dao"></property>
</bean>

<bean id="loggerBefore" class="cn.wgy.day01.aop.LoggerBefore"/>

<bean id="loggerAfter" class="cn.wgy.day01.aop.LoggerAfter"/>

<bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="targetName" value="biz"></property>
<property name="interceptorNames" value="loggerBefore,loggerAfter"></property>
</bean>

test

public static void main(String[] args) {

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//獲取到biz對象，即業務邏輯層對象

IUserBiz biz=(IUserBiz)ctx.getBean("serviceProxy");
User user=new User();
/**
* 執行這個方法時，先走前置增強，before（），然後走中間的方法，最後走後置增強
*/
biz.save2(user);
System.out.println("success!");
}

這個簡單的例子就很好的體現出了Spring AOP的力量

順便我們一起來看看其他增強類型

環繞增強：可以把前置增強和後置增強結合起來，spring吧目標的方法的控制權全部交給了它。我們要實現MethodInterceptor接口

aop：

public class AroundLog implements MethodInterceptor {
private static final Logger log = Logger.getLogger(AroundLog.class);

public Object invoke(MethodInvocation arg0) throws Throwable {
/*Object target = arg0.getThis(); // 獲取被代理對象
Method method = arg0.getMethod(); // 獲取被代理方法
Object[] args = arg0.getArguments(); // 獲取方法參數
log.info("調用 " + target + " 的 " + method.getName() + " 方法。方法入參："
+ Arrays.toString(args));
try { Object result = arg0.proceed(); // 調用目標方法，獲取目標方法返回值
log.info("調用 " + target + " 的 " + method.getName() + " 方法。 "
+ "方法返回值：" + result);
return result;
} catch (Throwable e) {
log.error(method.getName() + " 方法發生異常：" + e); throw e;
}*/
//環繞增強
System.out.println("===before=====");

//調用目標對象的方法
Object result = arg0.proceed();
System.out.println("===after=====");

return result;
}

applicationContext.xml：

<bean id="service" class="cn.wgy.day01.service.UserService"/>

<bean id="around" class="cn.wgy.day01.aop.AroundLog"/>

異常增強，我們要實現ThrowsAdvice接口

你注意看沒有，都沒有實現方法，怎麼辦呢？你別急，其實已經給我們規定了方法名稱，而且必須是它才能。就是 void AfterThrowing（）它提供了一個參數，三個參數的。

aop：

public class ErrorLog implements ThrowsAdvice {
private static final Logger log=Logger.getLogger(ErrorLog.class);

@SuppressWarnings("unused")
private void AfterThrowing(Method method, Object[] args, Object target,
RuntimeException e) {
log.error(method.getName()+"方法發生異常"+e);

}

service

public class UserService {
public void delete() {

int result=5/0;
System.out.println(result);

}
}

applicationContext.xml

<bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="service"></property>
<property name="interceptorNames" value="error"></property>
</bean>

到這裡我要思考一下，我們可以applicationContext.xml裡面的bean組件修改修改，我們用了顧問(Advisor)要包裝通知（Advice）,比較靈活，可以只針對某一個方法進行處理。

對於環繞增強：

<bean id="advisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
<property name="advice" ref="around"></property>
<property name="mappedNames" value="delete"></property>
</bean>

還有一個知識點，我們可以更方便的寫bean組件，正則表達式

</bean>

<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames" value="service"></property>
<property name="interceptorNames" value="regex"></property>
</bean>

到這裡呢，算是差不多了，但是我們缺少了分析下源代碼

我們知道，實現aop，其實源代碼裡面通過了動態代理來實現

我們來了解一下代理模式的定義：

為其他對象提供一種代理以控制對這個對象的訪問。在某些情況下，一個對象不適合或者不能直接引用另一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用。

代理模式使用代理對象完成用戶請求，屏蔽用戶對真實對象的訪問。

在軟件設計中，使用代理模式的意圖也很多，比如因為安全原因需要屏蔽客戶端直接訪問真實對象，或者在遠程調用中需要使用代理類處理遠程方法調用的技術細節 (如 RMI)，也可能為了提升系統性能，對真實對象進行封裝，從而達到延遲加載的目的。

代理模式角色分為 4 種：

主題接口：定義代理類和真實主題的公共對外方法，也是代理類代理真實主題的方法；

真實主題：真正實現業務邏輯的類；

代理類：用來代理和封裝真實主題；

Main：客戶端，使用代理類和主題接口完成一些工作。

1.什麼是動態代理?

答：動態代理可以提供對另一個對象的訪問，同時隱藏實際對象的具體事實。代理一般會實現它所表示的實際對象的接口。代理可以訪問實際對象，但是延遲實現實際對象的部分功能，實際對象實現系統的實際功能，代理對象對客戶隱藏了實際對象。客戶不知道它是與代理打交道還是與實際對象打交道。
2.為什麼使用動態代理?

答：因為動態代理可以對請求進行任何處理

3.哪些地方需要動態代理?

答：不允許直接訪問某些類；對訪問要做特殊處理等

JAVA 動態代理的作用是什麼？

主要用來做方法的增強，讓你可以在不修改源碼的情況下，增強一些方法，在方法執行前後做任何你想做的事情（甚至根本不去執行這個方法），因為在InvocationHandler的invoke方法中，你可以直接獲取正在調用方法對應的Method對象，具體應用的話，比如可以添加調用日志，做事務控制等。

還有一個有趣的作用是可以用作遠程調用，比如現在有Java接口，這個接口的實現部署在其它服務器上，在編寫客戶端代碼的時候，沒辦法直接調用接口方法，因為接口是不能直接生成對象的，這個時候就可以考慮代理模式（動態代理）了，通過Proxy.newProxyInstance代理一個該接口對應的InvocationHandler對象，然後在InvocationHandler的invoke方法內封裝通訊細節就可以了。具體的應用，最經典的當然是Java標准庫的RMI，其它比如hessian，各種webservice框架中的遠程調用，大致都是這麼實現的。

動態代理我們分之為jdk動態代理和cglib動態代理

JDK實現動態代理需要實現類通過接口定義業務方法，對於沒有接口的類，如何實現動態代理呢，這就需要CGLib了。CGLib采用了非常底層的字節碼技術，其原理是通過字節碼技術為一個類創建子類，並在子類中采用方法攔截的技術攔截所有父類方法的調用，順勢織入橫切邏輯。JDK動態代理與CGLib動態代理均是實現Spring AOP的基礎。

CGLib創建的動態代理對象性能比JDK創建的動態代理對象的性能高不少，但是CGLib在創建代理對象時所花費的時間卻比JDK多得多，所以對於單例的對象，因為無需頻繁創建對象，用CGLib合適，反之，使用JDK方式要更為合適一些。同時，由於CGLib由於是采用動態創建子類的方法，對於final方法，無法進行代理。

1.JDK動態代理

·此時代理對象和目標對象實現了相同的接口，目標對象作為代理對象的一個屬性，具體接口實現中，可以在調用目標對象相應方法前後加上其他業務處理邏輯。

代理模式在實際使用時需要指定具體的目標對象，如果為每個類都添加一個代理類的話，會導致類很多，同時如果不知道具體類的話，怎樣實現代理模式呢？這就引出動態代理。

JDK動態代理只能針對實現了接口的類生成代理。

看看代碼：

dao實現類

public class UserDaoImpl implements UserDao {

public void add() {
System.out.println("add success");
}

}

public class ProxySubject implements Subject {
private Subject realSubject;
public String request() {
System.out.println("代理增強");
return realSubject.request();
}
public Subject getRealSubject() {
return realSubject;
}
public void setRealSubject(Subject realSubject) {
this.realSubject = realSubject;
}

public class RealSubject implements Subject {

public String request() {
// TODO Auto-generated method stub
return "真實主題";
}

}

*/
public interface Subject {
public String request();
}

test

public static void main(String[] args) {
/**
* 靜態代理
*/
/*Subject sub=new RealSubject();//被代理對象
System.out.println(sub.toString());
ProxySubject ps=new ProxySubject();//代理對象
System.out.println(ps.toString());
ps.setRealSubject(sub);
String request = ps.request();//走真實代理對象 RealSubject
System.out.println(request);*/

/**
* 動態代理
*/
final UserDao dao=new UserDaoImpl();
//代理對象
//第一個參數：獲取和dao一樣的類加載器，通過反射機制獲取類加載器
//new InvocationHandler()叫匿名內部類，拿到了接口的實現類
UserDao newProxyInstance = (UserDao) Proxy.newProxyInstance(dao.getClass().getClassLoader(), dao.getClass().getInterfaces(), new InvocationHandler() {
//newProxyInstance 被代理對象
public Object invoke(Object newProxyInstance, Method method, Object[] args)
throws Throwable {
System.out.println("增強");
//原始對象 dao 真正的dao
Object invoke = method.invoke(dao, args);
System.out.println("記錄日志");
return invoke;
}

});
//增強代理對象，方法
newProxyInstance.add();
}

applicationContext.xml

2.CGLIB代理

CGLIB（CODE GENERLIZE LIBRARY）代理是針對類實現代理，主要是對指定的類生成一個子類，覆蓋其中的所有方法，所以該類或方法不能聲明稱final的。

如果目標對象沒有實現接口，則默認會采用CGLIB代理；

如果目標對象實現了接口，可以強制使用CGLIB實現代理（添加CGLIB庫，並在spring配置中加入<aop:aspectj-autoproxy proxy-target-class="true"/>）

public class CglibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
public Object getProxy(Class clazz){
//設置需要創建子類的類
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
//通過字節碼技術動態創建子類實例
return enhancer.create();
}
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("前置代理");
//通過代理類調用父類中的方法
Object result = proxy.invokeSuper(obj, args);
System.out.println("後置代理");
return result;
}

test

public class Test {
public static void main(String[] args) {
final UserService service=new UserService();
//1.創建
Enhancer enhancer=new Enhancer();
//2.設置根據哪個類生成子類
enhancer.setSuperclass(service.getClass());
//3.指定回調函數
enhancer.setCallback(new MethodInterceptor() {
//實現MethodInterceptor接口方法
public Object intercept(Object proxy, Method method, Object[] object,
MethodProxy methodproxy) throws Throwable {
//System.out.println("代碼增強");
System.out.println("前置代理");
//通過代理類調用父類中的方法
Object invoke = method.invoke(service, object);
System.out.println("後置代理");
return invoke;
}
});
//通過字節碼技術動態創建子類實例
UserService proxy = (UserService) enhancer.create();
proxy.delete();
}
}

applicationContext.xml

Spring AOP四種實現方式 http://www.linuxidc.com/Linux/2016-10/135993.htm

Spring AOP自定義注解方式實現日志管理 http://www.linuxidc.com/Linux/2015-11/125019.htm

Spring AOP進行日志記錄 http://www.linuxidc.com/Linux/2015-11/124731.htm

使用Spring AOP進行性能監控 http://www.linuxidc.com/Linux/2012-07/64681.htm

利用Spring AOP 更新Memcached 緩存策略的實現 http://www.linuxidc.com/Linux/2012-03/56503.htm

Spring AOP的兩種代理 http://www.linuxidc.com/Linux/2015-11/125017.htm

Spring AOP的注解實例 http://www.linuxidc.com/Linux/2015-11/125018.htm

上一頁:Java Swing 去掉按鈕文字周圍的焦點框
下一頁:Android sound driver拒絕服務漏洞(CVE-2016-6690)

Linux編程

Android ADT安裝技巧其常見錯誤處理

Android SAX解析XML

Python獲取遠程文件大小函數示例

atexit函數和兩種特殊文件權限位

用C語言求一組數組的最大值以及最小值

matlab在圖像中畫長方形(框)

如何將Android2.1源碼添加到自己的項目當中

Linux awk 內置變量實例

Linux教程網

Linux折騰記（十六）：數值計算和符號計算
不知道經常需要做科學計算的朋友們有沒有這樣的好奇：在Linux系統下使用什麼工具呢？說到科學計算，首先想到的肯

使用Linux建立IP隧道

Linux系統設置自動調整屏幕亮度的方法

Linux下執行程序某包Permission denied 的問題

Fedora Linux系統下掛載U盤和Windows盤

如何正確查看Linux機器內存使用情況

OpenSUSE 開機後直接加載 NTFS 分區

學習Linux驅動的過程中，遇到一個宏叫做container

Android調用系統聯系人返回聯系人結果

相关文章

CentOS中如何安裝配置proftp系統軟件
如何在Linux下安裝Node.js的Express
JavaScript中關於隱式轉換的一些總結
AngularJS + CoffeeScript 前端開發環境配置詳解
JavaScript基本類型及類型轉換
在 UNIX 和 Linux 系統上安裝和配置 WebSphere Application Server
Linux 6.3下安裝Oracle Enterprise Cloud Control 12C
Linux無線網絡技術概述：GPRS、GSM
RoseHAforSolaris快速安裝指引
Solaris學習筆記：關於Solaris的syslog機制
在Solaris9下安裝Oracle9IAS
Solaris應用經驗：VERITAS安裝記錄
基於LINUX系統的proftp的學習筆記（二）
基於LINUX系統的proftp的學習筆記（三）

Linux編程 SHELL編程 PERL編程

文章推荐

热点聚焦

Java多線程之ThreadPool

Ubuntu 10.04編譯LTP

在Linux下使用Openal來播放聲音類

Android加速度傳感器

Java 操作Excel 分析導出Execl

Android+Unity3D簡單的物體運動

Linux系統C語言學習總結

Android子線程真的不能更新UI麼

Linux poll函數深入理解

Python中用datetime包進行對時間的一些操作