互聯網 - 大數據

幾個小問題？
1、JVM初始化步驟 ？ 2、類初始化時機 ？3、哪幾種情況下，Java虛擬機將結束生命周期？
答案參考這篇文章jvm系列(一):java類的加載機制

方法區和對是所有線程共享的內存區域；而java棧、本地方法棧和程序員計數器是運行是線程私有的內存區域。

如何通過參數來控制個各個內存區域
參考此文章：jvm系列(二):JVM內存結構

GC算法和垃圾回收器算法圖解以及更詳細內容參考 jvm系列(三):GC算法 垃圾收集器

2016-07-05T10:43:18.093+0800: 25.395: [GC [PSYoungGen: 274931K->10738K(274944K)] 371093K->147186K(450048K), 0.0668480 secs] [Times: user=0.17 sys=0.08, real=0.07 secs] 
2016-07-05T10:43:18.160+0800: 25.462: [Full GC [PSYoungGen: 10738K->0K(274944K)] [ParOldGen: 136447K->140379K(302592K)] 147186K->140379K(577536K) [PSPermGen: 85411K->85376K(171008K)], 0.6763541 secs] [Times: user=1.75 sys=0.02, real=0.68 secs] 

詳細的命令使用參考這里jvm系列(四):jvm調優-命令篇

工具使用參考 jvm系列(七):jvm調優-工具篇

import java.net.URL;
import org.apache.log4j.Logger;
import org.codehaus.xfire.client.Client;
public class IServiceClient {
private static Logger logger = Logger.getLogger(IServiceClient.class);
public static String IServiceClient(String info) {
String result="false";
try { 
logger.debug("begin Other");
Client c1 = new Client(
new URL(
"http://127.0.0.1:8080/service/SendInfo?wsdl"));
logger.debug("init");
Object[] results1 = c1.invoke("setInfo",new Object[] { info});
logger.debug("invoke");
logger.debug(results1[0].toString());
result=results1[0].toString();
//Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
public static void main(String[] args) {
IServiceClient("1006");
}
}

public class test {
public static void main(String[] args) {
String arch = System.getProperty("sun.arch.data.model"); 
System.out.println(arch+"-bit");
}
}

yum -y install java-1.7.0-openjdk*
yum -y install ruby

1）查看 ulimit -n

2）更改

vim /etc/security/limits.conf

* soft nofile 65535

* hard nofile 65535

3)重啟linux

      reboot

vi /etc/my.cnf
最下面添加
binlog_format=row
max_allowed_packet = 52M
log_slave_updates = 1

同時停止同步

slave stop;

解壓 

tar -zxvf tungsten-replicator-2.2.1-403.tar.gz
cd tungsten-replicator-2.2.1-403
啟動 
./tools/tpm install mysql2mongodb \
--master=192.168.0.1 \
--install-directory=/opt/continuent \
--replication-user=root\
--replication-password=root\
--enable-heterogenous-master=true \
--repl-svc-extractor-filters=replicate \
--property=replicator.filter.replicate.do=zhongxin \
--property=replicator.filter.pkey.addColumnsToDeletes=true \
--property=replicator.filter.pkey.addPkeyToInserts=true \
--start

/opt/continuent/tungsten/tungsten-replicator/bin/trepctl status

state    : ONLINE 表示服務啟動正常

yum -y install java-1.7.0-openjdk*
yum -y install ruby

1）查看 ulimit -n

2）更改

vim /etc/security/limits.conf

* soft nofile 65535

* hard nofile 65535

3)重啟linux

      reboot

 ssh-keygen -t rsa 一路回車
cd .ssh/
cp id_rsa.pub authorized_keys
chmod 600 authorized_keys
scp authorized_keys root@192.168.0.2:/root/.ssh
chmod 700 -R .ssh

 驗證無密碼登錄：ssh 192.168.0.1 

解壓 

tar -zxvf tungsten-replicator-2.2.1-403.tar.gz
cd tungsten-replicator-2.2.1-403
啟動 
./tools/tungsten-installer --master-slave -a  \
     --datasource-type=mongodb \
     --datasource-port=27001 \
     --master-host=192.168.0.1     \
     --service-name=mysql2mongodb  \
     --home-directory=/opt/continuent \
     --java-file-encoding=UTF8 \
     --svc-parallelization-type=none \
     --start-and-report

/opt/continuent/tungsten/tungsten-replicator/bin/trepctl status

state    : ONLINE 表示服務啟動正常

start slave;

tail -300f /opt/continuent/tungsten/tungsten-replicator/log/trepsvc.log
tail -30f /opt/continuent/service_logs/trepsvc.log

/opt/continuent/tungsten/tungsten-replicator/bin/trepctl status
/opt/continuent/tungsten/tungsten-replicator/bin/trepctl services

/opt/continuent/tungsten/tungsten-replicator/bin/trepctl -service mysql2mongodb online
/opt/continuent/tungsten/tungsten-replicator/bin/trepctl status

--property=replicator.filter.replicate.ignore=zhongxin.zx_notice_req_log \

yum -y install curl wget lrzsz axel

a) tar -xf tcl8.6.1-src.tar.gz --strip-components=1 
b) cd tcl8.6.1/unix 
c) ./configure --prefix=/usr/local 
d) make
e) make test 
f) make install 
g) make install-private-headers 
h) ln -v -sf tclsh8.6 /usr/bin/tclsh 
i) chmod -v 755 /usr/lib/libtcl8.6.so（可選，并且如報找不到文件，沒關系）

wget http://download.redis.io/releases/redis-3.0.2.tar.gz 

tar xzf redis-3.0.2.tar.gz /usr/local/redis

cd redis-3.0.2

make MALLOC=libc

make test

make install 

a) mkdir /etc/redis 

b) mkdir /var/redis 

c) cp utils/redis_init_script /etc/init.d/redis

d) vim /etc/init.d/redis
頭部添加：

#chkconfig: 345 60 60

#!/bin/bash

e) mkdir /var/redis/6379 

f) cp redis.conf /etc/redis/6379.conf

g) vim /etc/redis/6379.conf
        #設置daemonize為yes
        #設置pidfile為/var/run/redis_6379.pid
        #設置loglevel
        #設置logfile為/var/log/redis_6379.log
        #設置dir為/var/redis/6379

h) sysctl vm.overcommit_memory=1

i) chkconfig --add redis

j) chkconfig redis on

service redis start/stop

ps -ef |grep redis
root 31927 25099 0 18:26 pts/0 00:00:00 vi /etc/init.d/redis

netstat -tupnl |grep redis
tcp 0 0 0.0.0.0:6379 0.0.0.0:* LISTEN 31966/redis-server 
tcp 0 0 :::6379 :::* LISTEN 31966/redis-server

yum -y list java* 

yum -y install openjdk-7-jdk

java -version
java version "1.7.0_91"
OpenJDK Runtime Environment (rhel-2.6.2.2.el6_7-x86_64 u91-b00)
OpenJDK 64-Bit Server VM (build 24.91-b01, mixed mode)

wget https://download.elastic.co/elasticsearch/elasticsearch/elasticsearch-1.7.2.noarch.rpm

rpm -ivh elasticsearch-1.7.2.noarch.rpm

cp /etc/elasticsearch/elasticsearch.yml /etc/elasticsearch/elasticsearch.yml.bak

echo "network.bind_host: 192.168.0.1" >> /etc/elasticsearch/elasticsearch.yml

/etc/init.d/elasticsearch start
/etc/init.d/elasticsearch stop

ps -ef |grep java

netstat -tupnl |grep java

curl -X GET http://192.168.54.147:9200
{
"status" : 200,
"name" : "Miguel O'Hara",
"cluster_name" : "elasticsearch",
"version" : {
"number" : "1.7.2",
"build_hash" : "e43676b1385b8125d647f593f7202acbd816e8ec",
"build_timestamp" : "2015-09-14T09:49:53Z",
"build_snapshot" : false,
"lucene_version" : "4.10.4"
},
"tagline" : "You Know, for Search"
}

update-rc.d elasticsearch defaults
update-rc.d: using dependency based boot sequencing

wget https://download.elastic.co/logstash/logstash/packages/centos/logstash-1.5.4-1.noarch.rpm

rpm -ivh logstash-1.5.4-1.noarch.rpm

vim /etc/logstash/conf.d/logstash_indexer.conf
input {
redis {
host => "192.168.0.1"
data_type => "list"
key => "logstash:redis"
type => "redis-input"
port => "6379"
}
}
output {
elasticsearch {
host => "192.168.0.1"
}
}

/etc/init.d/logstash start

ps -ef|grep logst

update-rc.d logstash defaults
update-rc.d: using dependency based boot sequencing

wget https://download.elastic.co/kibana/kibana/kibana-4.1.2-linux-x64.tar.gz

tar zxvf kibana-4.1.2-linux-x64.tar.gz -C /opt

mkdir -p /opt/kibanalog

cp /opt/kibana-4.1.2-linux-x64/config/kibana.yml /opt/kibana-4.1.2-linux-x64/config/kibana.yml.bak

sed -i 's!^elasticsearch_url: .*!elasticsearch_url: "http://192.168.0.1:9200"!g' /opt/kibana-4.1.2-linux-x64/config/kibana.yml
sed -i 's!^host: .*!host: "192.168.0.1"!g' /opt/kibana-4.1.2-linux-x64/config/kibana.yml

cd /opt/kibanalog && nohup /opt/kibana-4.1.2-linux-x64/bin/kibana &

ps aux |grep kibana

netstat -tupnl|grep 5601

echo "cd /opt/kibanalog && nohup /opt/kibana-4.1.2-linux-x64/bin/kibana &" >> /etc/rc.local

yum -y list java* 

yum -y install openjdk-7-jdk

wget https://download.elastic.co/logstash/logstash/packages/centos/logstash-1.5.4-1.noarch.rpm

rpm -ivh logstash-1.5.4-1.noarch.rpm

vim /etc/logstash/conf.d/logstash_agent.conf
input {
file {
path => "/tmp/*.log"
start_position => beginning
}
}
output {
redis {
host => "192.168.0.1"
data_type => "list"
key => "logstash:redis"
}
}

/etc/init.d/logstash start
logstash started.

ps -ef|grep logst

update-rc.d logstash defaults
update-rc.d: using dependency based boot sequencing

cat /var/log/redis/redis-server.log

cat /var/log/elasticsearch/elasticsearch.log
tail -300f /var/log/elasticsearch/elasticsearch.log

cat /var/log/logstash/logstash.errtail -30f /var/log/logstash/logstash.err

cat /opt/kibanalog/nohup.out
tail -30f /opt/kibanalog/nohup.out

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" 
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd 
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">
<bean id="test1DataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" >
<property name="driverClassName" value="${database.test1.driverClassName}" />
<property name="url" value="${database.test1.url}" />
<property name="username" value="${database.test1.username}" />
<property name="password" value="${database.test1.password}" />
</bean>
<bean id="test2DataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" >
<property name="driverClassName" value="${database.test2.driverClassName}" />
<property name="url" value="${database.test2.url}" />
<property name="username" value="${database.test2.username}" />
<property name="password" value="${database.test2.password}" />
</bean>
<bean id="test1SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> 
<property name="dataSource" ref="test1DataSource" />
<property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>
<property name="mapperLocations" value="classpath*:mybatis/mapper/*.xml" />
</bean> 
<bean id="test2SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> 
<property name="dataSource" ref="test2DataSource" />
<property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>
<property name="mapperLocations" value="classpath*:mybatis/mapper/*.xml" />
</bean> 
<bean id="test1TxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
<property name="dataSource" ref="test1DataSource"></property> 
</bean> 
<bean id="test2TxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
<property name="dataSource" ref="test2DataSource"></property> 
</bean> 
<tx:annotation-driven transaction-manager="test2TxManager" />
<tx:annotation-driven transaction-manager="test1TxManager" />
</beans>

package com.neo.dao;
import com.neo.entity.Entity;
public class BaseDao extends SessionFactory{
public void test1Update(Entity entity) {
this.getTest1Session().update(entity.getClass().getSimpleName()+".update", entity);
}
public void test2Update(Entity entity) {
this.getTest2Session().update(entity.getClass().getSimpleName()+".update", entity);
}
}

package com.neo.dao;
import com.neo.entity.Entity;
public class BaseDao extends SessionFactory{
public void test1Update(Entity entity) {
this.getTest1Session().update(entity.getClass().getSimpleName()+".update", entity);
}
public void test2Update(Entity entity) {
this.getTest2Session().update(entity.getClass().getSimpleName()+".update", entity);
}
}

package com.neo.service.impl;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.neo.dao.UserDao;
import com.neo.dao.UserInformationsDao;
import com.neo.entity.UserEntity;
import com.neo.entity.UserInformationsEntity;
import com.neo.service.UserService;
@Service
public class UserServiceImpl implements UserService {
@Resource UserDao userDao;
@Resource UserInformationsDao userInformationsDao;
@Override
@Transactional
public void updateUserinfo() {
UserEntity user=new UserEntity();
user.setId(1);
user.setUserName("李四4");
UserInformationsEntity userInfo=new UserInformationsEntity();
userInfo.setUserId(1);
userInfo.setAddress("陜西4");
userDao.updateUser(user);
userInformationsDao.updateUserInformations(userInfo);
if(true){
throw new RuntimeException("test tx ");
}
}
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" 
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd 
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">
<bean id="test1DataSource" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close">
<property name="uniqueResourceName" value="test1"/>
<property name="xaDataSourceClassName" value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource"/>
<property name="xaProperties">
<props>
<prop key="url">${database.test1.url}</prop>
<prop key="user">${database.test1.username}</prop>
<prop key="password">${database.test1.password}</prop>
</props>
</property>
<property name="minPoolSize" value="10" />
<property name="maxPoolSize" value="100" />
<property name="borrowConnectionTimeout" value="30" />
<property name="testQuery" value="select 1" />
<property name="maintenanceInterval" value="60" />
</bean>
<bean id="test2DataSource" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close">
<property name="uniqueResourceName" value="test2"/>
<property name="xaDataSourceClassName" value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource"/>
<property name="xaProperties">
<props>
<prop key="url">${database.test2.url}</prop>
<prop key="user">${database.test2.username}</prop>
<prop key="password">${database.test2.password}</prop>
</props>
</property>
<property name="minPoolSize" value="10" />
<property name="maxPoolSize" value="100" />
<property name="borrowConnectionTimeout" value="30" />
<property name="testQuery" value="select 1" />
<property name="maintenanceInterval" value="60" />
</bean>
<bean id="test1SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> 
<property name="dataSource" ref="test1DataSource" />
<property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>
<property name="mapperLocations" value="classpath*:mybatis/mapper/*.xml" />
</bean> 
<bean id="test2SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> 
<property name="dataSource" ref="test2DataSource" />
<property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>
<property name="mapperLocations" value="classpath*:mybatis/mapper/*.xml" />
</bean> 
<!-- 分布式事務 -->
<bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init" destroy-method="close">
<property name="forceShutdown" value="true"/>
</bean>
<bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">
<property name="transactionTimeout" value="300"/>
</bean>
<bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
<property name="transactionManager" ref="atomikosTransactionManager"/>
<property name="userTransaction" ref="atomikosUserTransaction"/>
</bean>
<tx:annotation-driven/>
</beans>

 spring簡介：

    spring是一個開源框架，spring是于2003 年興起的一個輕量級的Java 開發框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中闡述的部分理念和原型衍生而來。它是為了解決企業應用開發的復雜性而創建的。框架的主要優勢之一就是其分層架構，分層架構允許使用者選擇使用哪一個組件，同時為 J2EE 應用程序開發提供集成的框架。從簡單性、可測試性和松耦合的角度而言，任何Java應用都可以從spring中受益。spring的核心是控制反轉（IoC）和面向切面（AOP）。簡單來說，spring是一個分層的JavaSE/EEfull-stack(一站式) 輕量級開源框架。

   在開發人員的眼中spring是帝國一樣的存在，幾乎個個領域的技術都有spring的解決方案并且在基礎框架選型為spring后，后續相關的解決方案幾乎都是優先選擇spring相關組件，因此抽出時間來對常用的spring組件和原理進行學習、總結。

spring ioc:IOC是Inversion of Control的縮寫，多數書籍翻譯成“控制反轉”，還有些書籍翻譯成為“控制反向”或者“控制倒置”。本來是由應用程序管理的對象之間的依賴關系，現在交給了容器管理，這就叫控制反轉，即交給了IOC容器，spring的IOC容器主要使用DI方式實現的。不需要主動查找，對象的查找、定位和創建全部由容器管理。spring ioc 是spring的核心,在spring中主要用戶管理容器中的bean。

spring aop:AOP是OOP的延續，是Aspect Oriented Programming的縮寫，意思是面向方面編程。AOP實際是GoF設計模式的延續，設計模式孜孜不倦追求的是調用者和被調用者之間的解耦，AOP可以說也是這種目標的一種實現。spring aop 也是spring的核心,利用aop的技術可以用來做日志、權限、緩存等功能實現

spring orm:spring支持大多數ORM框架，比如Hibernate，JPA，JDO，TopLink和iBatis（spring2支持iBatis2，現MyBatis3的spring支持由MyBatis社區開發，并非spring）。

spring mvc:spring MVC框架是有一個MVC框架，通過實現Model-View-Controller模式來很好地將數據、業務與展現進行分離。從這樣一個角度來說，spring MVC和Struts、Struts2非常類似。

spring webservice:spring 支持集成Apache cxf、axis2、xfire等不同集中webservice實現方案。

spring transaction:spring完美的支持了對事物的管理，目前主要有兩種實現發難，一種是配置文件、一種是基于注解來實現。

spring jms:spring支持對activemq、RabbitMQ消息中間件的集成。

spring data:spring Data 作為springSource的其中一個父項目， 旨在統一和簡化對各類型持久化存儲， 而不拘泥于是關系型數據庫還是NoSQL 數據存儲。

spring cache:spring 的緩存技術還具備相當的靈活性，不僅能夠使用 SpEL（spring Expression Language）來定義緩存的 key 和各種 condition，還提供開箱即用的緩存臨時存儲方案，也支持和主流的專業緩存例如 EHCache 集成。

spring boot:spring-boot是由Pivotal團隊提供的全新框架，其設計目的是用來簡化新spring應用的初始搭建以及開發過程。該框架使用了特定的方式來進行配置，從而使開發人員不再需要定義樣板化的配置。通過這種方式，Boot致力于在蓬勃發展的快速應用開發領域（rapid application development）成為領導者。

spring security:spring Security是一個能夠為基于spring的企業應用系統提供聲明式的安全訪問控制解決方案的安全框架。它提供了一組可以在spring應用上下文中配置的Bean，充分利用了spring IoC，DI（控制反轉Inversion of Control ,DI:Dependency Injection 依賴注入）和AOP（面向切面編程）功能，為應用系統提供聲明式的安全訪問控制功能，減少了為企業系統安全控制編寫大量重復代碼的工作。

spring schedule:spring在schedule這塊支持JDK Timer、concurrent、quartz三種，這三種任務調度方案在實現機制和調用方法上都不同，但spring通過對其包裝，使得基于spring能用統一的配置和編碼風格來使用這三種schedule方案。

spring ioc是spring的核心之一，也是spring體系的基礎，那么spring ioc所依賴的底層技術是什么的？反射，以前我們開發程序的時候對象之間的相互調用需要用new來實現，現在所有的bean都是通過spring容器來管理。這樣做有什么好處呢？解耦！以前程序直接的調用用new直接給寫死了，現在我們可以通過注入不同的接口實現類來完成對象直接的調用。

首先來聊聊Java的反射機制

1、反射機制的作用：

  反編譯：.class-->.java

  通過反射機制訪問java對象的屬性，方法，構造方法等；

2、Java反射機制用途：

  在運行時判斷任意一個對象所屬的類

  在運行時構造任意一個類的對象

  在運行時判斷任意一個類所具有的成員變量和方法

  在運行時調用任意一個對象的方法

3、sun為我們提供了那些反射機制中的類：

 java.lang.Class; 
java.lang.reflect.Constructor; 
java.lang.reflect.Field; 
java.lang.reflect.Method;
java.lang.reflect.Modifier;

4、反射實現的方式

Class c=Class.forName("className");
注明：className必須為全名，也就是得包含包名，比如，cn.xx.UserInfo;
Object obj=c.newInstance();
//創建對象的實例 

Constructor getConstructor(Class[] params)
//根據指定參數獲得public構造器 

Constructor[] getConstructors()
//獲得public的所有構造器 

Constructor getDeclaredConstructor(Class[] params)
//根據指定參數獲得public和非public的構造器 

Constructor[] getDeclaredConstructors()
//獲得public的所有構造器 

ewInstance();
//創建對象的實例 

獲得類方法的方法
Method getMethod(String name, Class[] params),
根據方法名，參數類型獲得方法 
Method[] getMethods()
//獲得所有的public方法 

Method getDeclaredMethod(String name, Class[] params)
//根據方法名和參數類型，獲得public和非public的方法 

Method[] getDeclaredMethods()
//獲得所以的public和非public方法

獲得類中屬性的方法
Field getField(String name)
//根據變量名得到相應的public變量 

Field[] getFields()
//獲得類中所以public的方法 

Field getDeclaredField(String name)
//根據方法名獲得public和非public變量 

Field[] getDeclaredFields()
//獲得類中所有的public和非public方法

總結一句,以前寫的代碼，類的熟悉、方法什么東西的都固定了，如果使用反射我們就可以在運行的時候動態的去修改、增刪對象的熟悉、方法等等。

spring IOC是如果使用反射來完成對象的注入呢？

1、讀取配置文件，或者掃描注解屬性

2、根據配置文件，通過反射實例化對象

3、給對象注入依賴的屬性

4、放到類似hashMap結構中，供系統調用

/**
* 學習版容器
*
*/

public class LeamClassPathXMLApplicationContext {
private List<Definition> beanDefines = new ArrayList<Definition>();
private Map<String, Object> sigletons = new HashMap<String, Object>();
public LeamClassPathXMLApplicationContext(String filename){
this.readXML(filename);
this.instanceBeans();
this.injectObject();
}
/**
* 為bean對象的屬性注入值
*/
private void injectObject() {
for(Definition beanDefinition : beanDefines){
Object bean = sigletons.get(beanDefinition.getId());
if(bean!=null){
try {
PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
for(ProsDefinition propertyDefinition : beanDefinition.getPropertys()){
for(PropertyDescriptor properdesc : ps){
if(propertyDefinition.getName().equals(properdesc.getName())){
Method setter = properdesc.getWriteMethod();//獲取屬性的setter方法 
if(setter!=null){
Object value = sigletons.get(propertyDefinition.getRef());
setter.setAccessible(true);
setter.invoke(bean, value);//把引用對象注入到屬性 }
break;
}
}
}
} catch (Exception e) {
}
}
}
}
/**
* 完成bean的實例化
*/
private void instanceBeans() {
for(Definition beanDefinition : beanDefines){
try {
if(beanDefinition.getClassName()!=null && !"".equals(beanDefinition.getClassName().trim()))
sigletons.put(beanDefinition.getId(), 
Class.forName(beanDefinition.getClassName()).newInstance());
} catch (Exception e) {
e.printStackTrace();
}
} 
}
/**
* 讀取xml配置文件
* @param filename
*/
private void readXML(String filename) {
SAXReader saxReader = new SAXReader(); 
Document document=null; 
try{
URL xmlpath = this.getClass().getClassLoader().getResource(filename);
document = saxReader.read(xmlpath);
Map<String,String> nsMap = new HashMap<String,String>();
nsMap.put("ns","http://www.springframework.org/schema/beans");//加入命名空間
 XPath xsub = document.createXPath("//ns:beans/ns:bean");//創建beans/bean查詢路徑
xsub.setNamespaceURIs(nsMap);//設置命名空間
 List<Element> beans = xsub.selectNodes(document);//獲取文檔下所有bean節點 
for(Element element: beans){
String id = element.attributeValue("id");//獲取id屬性值
 String clazz = element.attributeValue("class"); //獲取class屬性值 
 Definition beanDefine = new Definition(id, clazz);
XPath propertysub = element.createXPath("ns:property");
propertysub.setNamespaceURIs(nsMap);//設置命名空間
 List<Element> propertys = propertysub.selectNodes(element);
for(Element property : propertys){ 
String propertyName = property.attributeValue("name");//元素內部引用的屬性也獲取
 String propertyref = property.attributeValue("ref");
ProsDefinition propertyDefinition = new ProsDefinition(propertyName, propertyref);
beanDefine.getPropertys().add(propertyDefinition);
}
beanDefines.add(beanDefine);
} 
}catch(Exception e){ 
e.printStackTrace();
}

 }
/**
* 獲取bean實例
* @param beanName
* @return
*/
public Object getBean(String beanName){
return this.sigletons.get(beanName);
}
}

spring ioc核心思想

ioc的思想最核心的地方在于，資源不由使用資源的雙方管理，而由不使用資源的第三方管理，這可以帶來很多好處。第一，資源集中管理，實現資源的可配置和易管理。第二，降低了使用資源雙方的依賴程度，也就是我們說的耦合度。

什么是AOP

AOP（Aspect-OrientedProgramming，面向方面編程），它利用一種稱為“橫切”的技術，剖解開封裝的對象內部，并將那些影響了多個類的公共行為封裝到一個可重用模塊，并將其名為“Aspect”，即方面。所謂“方面”，簡單地說，就是將那些與業務無關，卻為業務模塊所共同調用的邏輯或責任封裝起來，便于減少系統的重復代碼，降低模塊間的耦合度，并有利于未來的可操作性和可維護性。

AOP使用場景

AOP用來封裝橫切關注點，具體可以在下面的場景中使用:

Authentication 權限

Caching 緩存

Context passing 內容傳遞

Error handling 錯誤處理

Lazy loading　懶加載

Debugging　　調試

logging, tracing, profiling and monitoring　記錄跟蹤　優化　校準

Performance optimization　性能優化

Persistence　　持久化

Resource pooling　資源池

Synchronization　同步

Transactions 事務

Spring AOP底層技術

Spring提供了兩種方式來生成代理對象: JDKProxy和Cglib，具體使用哪種方式生成由AopProxyFactory根據AdvisedSupport對象的配置來決定。默認的策略是如果目標類是接口，則使用JDK動態代理技術，否則使用Cglib來生成代理。

動態代理利用反射的原理，給對象動態的生產代理對象，在執行的方法前后來執行相關內容：

/**
* 動態代理類
* 
* @author yanbin
* 
*/
public class DynamicProxy implements InvocationHandler {
/** 需要代理的目標類 */
private Object target;

/**
* 寫法固定，aop專用:綁定委托對象并返回一個代理類
* 
* @param delegate
* @return
*/
public Object bind(Object target) {
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
/**
* @param Object
* target：指被代理的對象。
* @param Method
* method：要調用的方法
* @param Object
* [] args：方法調用時所需要的參數
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
// 切面之前執行
System.out.println("切面之前執行");
// 執行業務
result = method.invoke(target, args);
// 切面之后執行
System.out.println("切面之后執行");
return result;
}
}

CGLIB是針對類來實現代理的，他的原理是對指定的目標類生成一個子類，并覆蓋其中方法實現增強。采用的是繼承的方式

/**
* 使用cglib動態代理
* 
* @author yanbin
* 
*/
public class CglibProxy implements MethodInterceptor {
private Object target; 
/**
* 創建代理對象
* 
* @param target
* @return
*/
public Object getInstance(Object target) {
this.target = target;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(this.target.getClass());
// 回調方法
 enhancer.setCallback(this);
// 創建代理對象
return enhancer.create();
}
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object result = null;
System.out.println("事物開始");
result = methodProxy.invokeSuper(proxy, args);
System.out.println("事物結束");
return result;
} 
}

AOP相關概念

方面（Aspect）：一個關注點的模塊化，這個關注點實現可能另外橫切多個對象。事務管理是J2EE應用中一個很好的橫切關注點例子。方面用Spring的 Advisor或攔截器實現。

連接點（Joinpoint）: 程序執行過程中明確的點，如方法的調用或特定的異常被拋出。

通知（Advice）: 在特定的連接點，AOP框架執行的動作。各種類型的通知包括“around”、“before”和“throws”通知。通知類型將在下面討論。許多AOP框架包括Spring都是以攔截器做通知模型，維護一個“圍繞”連接點的攔截器鏈。Spring中定義了四個advice: BeforeAdvice, AfterAdvice, ThrowAdvice和DynamicIntroductionAdvice

切入點（Pointcut）: 指定一個通知將被引發的一系列連接點的集合。AOP框架必須允許開發者指定切入點：例如，使用正則表達式。 Spring定義了Pointcut接口，用來組合MethodMatcher和ClassFilter，可以通過名字很清楚的理解， MethodMatcher是用來檢查目標類的方法是否可以被應用此通知，而ClassFilter是用來檢查Pointcut是否應該應用到目標類上

引入（Introduction）: 添加方法或字段到被通知的類。 Spring允許引入新的接口到任何被通知的對象。例如，你可以使用一個引入使任何對象實現 IsModified接口，來簡化緩存。Spring中要使用Introduction, 可有通過DelegatingIntroductionInterceptor來實現通知，通過DefaultIntroductionAdvisor來配置Advice和代理類要實現的接口

目標對象（Target Object）: 包含連接點的對象。也被稱作被通知或被代理對象。POJO

AOP代理（AOP Proxy）: AOP框架創建的對象，包含通知。 在Spring中，AOP代理可以是JDK動態代理或者CGLIB代理。

織入（Weaving）: 組裝方面來創建一個被通知對象。這可以在編譯時完成（例如使用AspectJ編譯器），也可以在運行時完成。Spring和其他純Java AOP框架一樣，在運行時完成織入。

幾種實現方式

1、基于代理的AOP

2、純簡單java對象切面

3、@Aspect注解形式的

4、注入形式的Aspcet切面

面先寫一下幾個基本的類。

接口類：

/**
* 定義一個接口
* @author 陳麗娜
* @version 2015年5月31日上午9:16:50
*/
public interface Sleepable {
/**
* 睡覺方法
* @author 陳麗娜
* @version 2015年5月31日上午9:17:14
*/
void sleep();
}

實現類：

/**
* 陳麗娜 本人實現睡覺接口
* @author 陳麗娜
* @version 2015年5月31日下午4:51:43
*/
public class ChenLliNa implements Sleepable {
@Override
public void sleep() {
// TODO Auto-generated method stub
 System.out.println("乖,該睡覺了！");
}
}

增強類：

/**
* 定義一個睡眠的增強 同時實現前置 和后置
* @author 陳麗娜
* @version 2015年5月31日上午9:24:43
*/
public class SleepHelper implements MethodBeforeAdvice, AfterReturningAdvice {
@Override
public void afterReturning(Object returnValue, Method method,Object[] args, Object target) throws Throwable {
System.out.println("睡覺前要敷面膜");
}
@Override
public void before(Method method, Object[] args, Object target)throws Throwable {
System.out.println("睡覺后要做美夢");
}
}

1、基于代理的AOP

<!-- 創建一個增強 advice -->
<bean id ="sleepHelper" class="com.tgb.springaop.aspect.SleepHelper"/>
<bean id="lina" class="com.tgb.springaop.service.impl.ChenLliNa"/>
<!-- 定義切點 匹配所有的sleep方法-->
<bean id ="sleepPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
<property name="pattern" value=".*sleep"></property>
</bean>
<!-- 切面 增強+切點結合 -->
<bean id="sleepHelperAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
<property name="advice" ref="sleepHelper"/>
<property name="pointcut" ref="sleepPointcut"/>
</bean> 
<!-- 定義代理對象 -->
<bean id="linaProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="lina"/>
<property name="interceptorNames" value="sleepHelperAdvisor"/>
</bean>

如配置文件中：

pattern屬性指定了正則表達式，他匹配所有的sleep方法

使用org.springframework.aop.support.DefaultPointcutAdvisor的目的是為了使切點和增強結合起來形成一個完整的切面

最后配置完后通過org.springframework.aop.framework.ProxyFactoryBean產生一個最終的代理對象。

2、純簡單java對象切面

純簡單java對象切面這話怎么說呢，在我看來就是相對于第一種配置，不需要使用代理，，而是通過spring的內部機制去自動掃描，這時候我們的配置文件就該如下修改：

<!-- 創建一個增強 advice -->
<bean id ="sleepHelper" class="com.tgb.springaop.aspect.SleepHelper"/>
<!-- 目標類 -->
<bean id="lina" class="com.tgb.springaop.service.impl.ChenLliNa"/>
<!-- 配置切點和通知-->
<bean id ="sleepAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice" ref="sleepHelper"></property>
<property name="pattern" value=".*sleep"/>
</bean>
<!-- 自動代理配置 -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>

是不是相對于第一種簡單了許多，不用再去配置代理了。

3、@Aspect注解形式

根據我們的經驗也知道，注解的形式相對于配置文件是簡單一些的，這時候需要在已有的方法或類上家注解：

/**
* 通過注解的方式 添加增強
* @author 陳麗娜
* @version 2015年5月31日上午10:26:13
*/
@Aspect
@Component
public class SleepHelper03 { 

/*@Pointcut("execution(* com.tgb.springaop.service.impl..*(..))")*/
@Pointcut("execution(* *.sleep(..))")
public void sleeppoint(){}
@Before("sleeppoint()")
public void beforeSleep(){
System.out.println("睡覺前要敷面膜");
}
@AfterReturning("sleeppoint()")
public void afterSleep(){
System.out.println("睡覺后要做美夢");
}

配置文件中只需寫：

<!--掃描包 -->
<context:component-scan base-package="com.tgb" annotation-config="true"/> 
<!-- ASPECTJ注解 -->
<aop:aspectj-autoproxy proxy-target-class="true" /> 
<!-- 目標類 -->
<bean id="lina" class="com.tgb.springaop.service.impl.ChenLliNa"/>

4、注入形式的Aspcet切面

個人感覺這個是最簡單的也是最常用的，也是最靈活的。配置文件如下：

<!-- 目標類 -->
<bean id="lina" class="com.tgb.springaop.service.impl.ChenLliNa"/>
<bean id ="sleepHelper" class="com.tgb.springaop.aspect.SleepHelper02"/>
<aop:config>
<aop:aspect ref="sleepHelper">
<aop:before method="beforeSleep" pointcut="execution(* *.sleep(..))"/>
<aop:after method="afterSleep" pointcut="execution(* *.sleep(..))"/>
</aop:aspect>
</aop:config>

配置文件中提到的SleepHelper02類如下：

/**
* 通過注解的方式 添加增強
* @author 陳麗娜
* @version 2015年5月31日上午10:26:13
*/
public class SleepHelper02 {
public void beforeSleep(){
System.out.println("睡覺前要敷面膜");
}
public void afterSleep(){
System.out.println("睡覺后要做美夢");
}
}

參考：http://itindex.net/detail/53556-spring-aop