Spring的组成

1、    Core模块

该模块是Spring的核心容器，它实现了Ioc模式和Spring框架的基础功能。

2、    Context模块

该模块继承BeanFactory类，并添加了事件处理、国际化、资源加载、透明加载已经数据检验等功能。

3、    Aop模块

  Spring集成了所以Aop功能，通过事务管理可以任意Spring管理的对象Aop化。

4、    Dao模块

该模块提供了JDbc的抽象层，简化了数据库厂商的异常处理。

5、    Orm映射模块

该模块提供了对现有ORM框架支持，为Hibernate提供了完美的结合。

6、    web模块

该模块建立在SpringContext基础之上，提供了Servlet监视器的Context和web应用的上下文，为现有Web框架提供了集成。

7、    MVC模块

实现了控制逻辑和业务逻辑的清晰分离。

Spring的包

包名    说明

Org.springframework.aop-3.1.1.release.jar    Spring的Aop模块

Org.springframework.asm-3.1.1.release.jar    Spring独立的asm程序，需要asm.jar包

Org.springframework.aspects-3.1.1.release.jar    Spring提供对Aspectj框架的整合

Org.springframework.beans-3.1.1.release.jar    Ioc的实现

Org.springframework.context.support-3.1.1.release.jar    MVC扩展支持

Org.springframework.context-3.1.1.release.jar    Spring的上下文，spring提供在基础ioc功能上的扩展服务，此外还提供许多企业级服务的支持，如邮件服务器、任务调度、JNDI定位、Ejb集成等。

Org.springframework.core-3.1.1-release.jar    Spring的核心模块

Org.springframework.expreesion-3.1.1.release.jar    Spring的表达式语言

Org.springframework.instrument.tomcat-3.1.1.release.jar    tomcat连接池的支持

Org.springframework.instrument-3.1.1.release.jar    对服务器的代理接口

Org.springframework.jdbc-3.1.1.release.jar    jdbc模块

Org.springframework.jms-3.1.1.release.jar    JMS  API使用的简单封装

Org.springframework.orm-3.1.1-release.jar    Orm模块,支持Hibernate和JDO等orm工具

Org.springframework.oxm.3.1.1-release.jar    对Object/XML的映射支持

Org.springframework.test-3.1.1.release.jar    对Junit等测试框架的简单封装

Org.springframework.transaction-3.1.1.release.jar    jdbc、Hibernate、jdo、jpa等提供一致的声明式和编程式事务关联

Org.springframework.web.portlet-3.1.1.release.jar    Mvc的增强

Org.springframework.web.servlet-3.1.1.release.jar    对java EE6.0和Servlet3.0的支持

Org.springframework.web.struts-3.1.1.release.jar    整合struts

Org.springframework.web-3.1.1.release.jar    web模块，包含web application context

需要其他包的支持commons-logging.jar和aopalliance.jar的支持。

BeanFactory关联bean

BeanFactory采用了java的工厂模式，通过配置xml文件或属性文件.properties中读取javabean的定义来创建、配置和关联javaBean。BeanFactory有很多实现类，其中，xmlBeanFactory类通过xml文件格式读取配置信息加载javaBean。

//获取配置文件

Resource resource = new ClassPathResource("applicationContext.xml");            //装载配置文件

            BeanFactory factory = new XmlBeanFactory(resource);

            User user = (User) factory.getBean("user");

bean的生命周期

    实例化javabean、初始化javaBean、使用javabean和销毁javaBean共4个阶段。

applicationContext接口的创建。

applicationContext接口有3个实现类：ClassPathXmlApplicationContext类、FileSystemXmlApplicationContext类、WebApplicationContext类。

1、    ClassPathXmlApplicationContext类创建

      ApplicationContext context=new ClassPathXmlApplicationContext(Sting configlocation);

通过参数指定spring的xml文件的位置来创建applicationContext容器。

2、FileSystemXmlApplicationContext类创建

     ApplicationContext context=new FileSystemXmlApplicationContext(Sting configlocation);

通过参数指定spring的xml文件的位置来创建applicationContext容器。

3、WebApplicationContext类创建

WebApplicationContext是spring的web容器，在Servlet中使用该类的方法有2种：一是在Servlet的web.xml文件中陪spring的ContextLoaderListener监听器；而是修改web.xml文件，在其中添加一个Servlet，定义使用spring的org.springframework.web.context.ContextLoaderServlet类。

依赖注入

1、    接口注入，Spring不支持。

2、    Setter注入，通过javaBean的setter方法为属性赋值，广泛应用。

3、    构造器注入，javaBean的有参构造方法给属性赋值。

Seter注入实例

User类

package com.User;

public class User {

    private Integer id;

    private String name;

    private String age;

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getAge() {

        return age;

    }

    public void setAge(String age) {

        this.age = age;

    }

}

在ApplicationContext.xml配置文件里添加Bean

<?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-3.0.xsd">

    <!-- User实体 -->

    <bean name="user" class="com.User.User">

    <property name="id"><value>1</value></property>

    <property name="name"><value>小明</value></property>

    <property name="age"><value>15</value></property>

    </bean>

    </beans>

使用Manager类的main方法测试setter注入

public static void main(String[] args) {

        // TODO Auto-generated method stub

        //加载配置文件

        Resource resource=new ClassPathResource("applicationContext.xml");

        //初始化beanFactory

        BeanFactory factory=new XmlBeanFactory(resource);

        //获取Bean

        User user=(User)factory.getBean("user");

        //输出bean信息

        System.out.println(user.getId());

        System.out.println(user.getName());

        System.out.println(user.getAge());

    }

使用构造器注入

User类

package com.User;

public class User {

    private Integer id;

    private String name;

    private String age;

    //构造方法

    public User(Integer id,String name,String age){

        this.id=id;

        this.name=name;

        this.age=age;

    }

    //值输出方法

    public void printinfo(){

        System.out.println(id);

        System.out.println(name);

        System.out.println(age);

    }

}

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-3.0.xsd">

    <!-- User实体 -->

    <bean name="user" class="com.User.User">

    <!-- 构造器注入，要使用标签<constructor-arg> -->

    <constructor-arg><value>1</value></constructor-arg>

    <constructor-arg><value>小明</value></constructor-arg>

    <constructor-arg><value>15</value></constructor-arg>

    </bean>

    </beans>

Manager类的main测试方法

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        //加载配置文件

        Resource resource=new ClassPathResource("applicationContext.xml");

        //初始化beanFactory

        BeanFactory factory=new XmlBeanFactory(resource);

        //获取Bean

        User user=(User)factory.getBean("user");

        //输出bean信息

        user.printinfo();

    }

引用其他Bean

User类

package com.US;

public class User {

    private Integer id;

    private String name;

    private String age;

…//省略setter和getter方法

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-3.0.xsd">

     <!-- 注册User类到bean -->

     <bean id="user" class="com.US.User">

     <property name="id"><value>1</value></property>

     <property name="name"><value>xiaoming</value></property>

     <property name="age"><value>14</value></property>

     </bean>

    <!-- 注入javaBean -->

    <bean name="/main.do" class="com.US.Manager">

    <property name="user">

    <ref local="user"/>

    </property>

    </bean>

    </beans>

Manager类

package com.US;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;

import org.springframework.web.servlet.mvc.AbstractController;

//Manager继承Spring的AbstracController的控制器；AbstractController在web.servlet.mvc的jar包里

public class Manager extends AbstractController {

    //引入User类作属性，通过Spring注入到对象user

    private User user;

    public User getUser() {

        return user;

    }

    public void setUser(User user) {

        this.user = user;

    }

    //实现handleRequestInternal抽象方法用来实在自己的业务逻辑

    protected ModelAndView handleRequestInternal(

            HttpServletRequest arg0,HttpServletResponse arg1) throws Exception{

        user.printinfo();//执行user的输出方法

        return null;

    }

}

Spring的配置文件ApplicationContext.xml要放到Web-Inf文件夹下，保证web.xml文件引用是可以找的到。项目启动时Spring自动加载ApplicationContext.xml文件配置信息。

Web.xml配置ApplicationContext.xml文件

<!-- 通过Servlet配置Spring的自动加载文件 -->

  <servlet>

  <servlet-name>dispatcherServlet</servlet-name>

  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

  <init-param>

  <param-name>contextConfigLocation</param-name>

  <param-value>/WEB-INF/applicationContext.xml</param-value>

  </init-param>

  <load-on-startup>1</load-on-startup>

  </servlet>

  <servlet-mapping>

  <servlet-name>dispatcherServlet</servlet-name>

  <url-pattern>*.do</url-pattern>

  </servlet-mapping>

创建匿名内部JavaBean

    <!-- 创建匿名JavaBean -->

    <bean id="school" class="School">

    <property name="user">

    <bean class="com.US.User"/>

    </property>

    </bean>

Spring Aop

Aop术语

1、切面(aspect)

切面就是程序中的一段段互不相干的代码。

2、连接点(join Point)

连接点是指对象的一个操作，比如对象调用一个方法，或对象某个方法抛出异常等。

3、切入点(Pointuct)

切入点就是连接点的集合，可以理解为一段程序流中对象多个连接点的集合，也就是对象调用了多个方法，或抛出多个异常。

4、通知(advice)

通知就是在切入点处告诉程序要执行切面的业务逻辑。

5、目标对象(target)

被通知的对象就叫目标对象。也可以理解为被代理的对象。目标对象作业务处理。

6、织入(weaving)

织入是将切面功能应用到目标对象的过程，有代理工厂创建一个代理对象，代理对象可以为目标对象执行切面功能。

3种织入方式：编译时期（complie time）织入、类加载时期（Classlocad  time）织入、执行时期（runtime）织入。最常用的是执行时期织入。

9、引入(introduction)

对一个已编译的类（Class），在运行时期动态向其中加载属性和方法。

Spring的切入点

切入点的3种类型：静态切入点、动态切入点和自定义切入点。

静态切入点可以为对象的方法签名，对象调用对象的方法时，这个方法就是静态切入点。静态切入点需要在配置文件中指定。

<bean id=”pointAdvisor” class=”org.springframework.aop.support.RegexpMethodPointAdvisor”>

<property name=”advice”>

<ref bean=”MyAdvisor”/><!—指定通知-->

</property>

<property name=”patterns”>

<list>

<value>.*getConn*.</value><!—指定所以以getConn开头的方法都是切入点-->

<value>.*closeConn*.</value>

</list>

</property>

</bean>

由于静态切入点只在代理创建是执行一次，然后缓存结果。下一次调用时直接从缓存中读取即可，所以在性能上要远高于动态切入点。

但是当需要通知的目标对象的类型多于一种，而且需要织入的方法很多时，用静态切入点编程会很烦琐，并且不够灵活且会降低性能，这时可以选用动态切入点。

动态切入点

动态切入点可应用在相对变化的位置，如方法的参数上。由于程序运行过程中的传递的参数变化，切入点也随这变化，它会根据不同的参数来织入不同的切面。

深入静态切入点

静态切入点在某个方法名上织入切面，所以在织入程序代码前要匹配方法名，判断当前正在调用的方法是不是已经定义的静态切入点。匹配成功并织入切面；配置失败不织入切面。匹配的过程是有Spring自动实现，不需要编程的干预。

Spring中的其他切入点

切入点的实现类    说明

Org.springframework.support.JdkRegexpMethodPointcut    JDK正则表达式方法切入点

Org.springframework.support.NameMatchMethodPointcut    名称匹配器方法切入点

Org.springframework.support.StaticMatchMethodPointcut    静态方法匹配器切入点

Org.springframework.support.ControlFlowPointcut    流程切入点

Org.springframework.support.DynamicMethodMatcherPointcut    动态方法切入点

Spring持久化

Dao模式：Dao属于O/R Mapping技术的一种，通过O/R技术实现与RDBMS（关系数据库管理系统）的交互。

Spring的Dao理念

SpringDao框架存取数据时，通过一个数据存取接口来操作。

创建User类

public class User {

    private Integer id;

    private String name;

    private String age;

…//省略setter和getter

UserDaoimpl接口

public interface UserDaoimpl {

    public void inserUser(User user);//添加用户信息

}

UserDao实现

import java.sql.Connection;

import java.sql.Statement;

import javax.sql.DataSource;

public class UserDao implements UserDaoimpl {

    private DataSource datasource;

    public DataSource getDatasource() {

        return datasource;

    }

    public void setDatasource(DataSource datasource) {

        this.datasource = datasource;

    }

    //添加数据

    public void inserUser(User user){

        int id=user.getId();

        String name=user.getName();

        String age=user.getAge();

        Connection con=null;

        Statement st=null;

        try{

            con=datasource.getConnection();

            st=con.createStatement();

            st.execute("insert into tb_user(id,name,age) values ('"+id+"','"+name+"','"+age+"')");

            st.close();

            con.close();

        }catch(Exception e){

            e.printStackTrace();

        }

    }

}

applicationContext.xml配置信息

    <!-- 配置数据源 -->

 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

 <property name="driverClassName">

 <value>oracle.jdbc.driver.OracleDriver</value>

 </property>

 <property name="url">

 <value>jdbc:oracle:thin:@127.0.0.1:1521:orcl</value>

 </property>

 <property name="username">

 <value>system</value>

 </property>

 <property name="password">

 <value>guoyanan</value>

 </property>

 </bean>

 <!-- 注入UserDao注入数据 -->

 <bean id="userDao" class="com.US.UserDao">

 <property name="datasource" >

 <ref local="dataSource"/>

 </property>

 </bean>

Main方法执行

public static void main(String[] args){

         Resource resource = new ClassPathResource("applicationContext.xml");            //装载配置文件

            BeanFactory factory = new XmlBeanFactory(resource);

        User user=new User();

        user.setId(3);

        user.setName("xxx");

        user.setAge("12");

        UserDao userDAO = (UserDao) factory.getBean("userDao");//获取UserDAO

            userDAO.inserUser(user);//执行添加方法

        System.out.println("OK");

    }

事务管理

事务管理在应用程序中至关重要，它是一系列任务组的工作单元，其中的所有任务 必须同时执行。执行结果：全部成功和全部失败。

1、编程式事务管理

Sping中主要有2中编程式事务管理实现方法，分别通过使用Plaform  Transaction  Manager接口的事务管理器或Transaction  Template实现。推荐使用Transaction  Template实现方式，符合Spring的模版模式。

在Spring配置文件中声明事务管理器和TransactionTemplate。

<!-- 配置数据源 -->

 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

 <property name="driverClassName">

 <value>oracle.jdbc.driver.OracleDriver</value>

 </property>

 <property name="url">

 <value>jdbc:oracle:thin:@127.0.0.1:1521:orcl</value>

 </property>

 <property name="username">

 <value>system</value>

 </property>

 <property name="password">

 <value>guoyanan</value>

 </property>

 </bean>

    <!-- 定义TransactionTemplate模版 -->

    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">

    <property name="transactionManager">

    <ref bean="transactionManager"/>

    </property>

    <property name="propagationBehaviorName">

    <!-- 限定事务的传播行为，规定当前方法必须运行在事务中，

    如果没有事务，则创建一个。一个新的事务和方法同时开始，

    随这方法返回或抛出异常终止。 -->

    <value>PROPAGATION_REQUIRED</value>

    </property>

    </bean>

    <!-- 定义事务管理器 -->

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

    <property name="dataSource">

    <ref bean="dataSource"/>

    </property>

    </bean>

    <!-- 注入事务管理器 -->

    <bean id="transactionExample" class="com.US.TranscationExample">

    <property name="dataSource">

    <ref bean="dataSource"/>

    </property>

    <property name="transactionManager">

    <ref bean="transactionManager"/>

    </property>

    <property name="transactionTemplate">

    <ref bean="transactionTemplate"/>

    </property>

    </bean>

创建类transactionExample。

public class TranscationExample {

    //注入数据源

    DataSource dataSource;

    //注入事务管理器

    PlatformTransactionManager  transactionManager;

    //注入事务管理模版

    TransactionTemplate  transactionTemplate;

    public DataSource getDataSource() {

        return dataSource;

    }

    public void setDataSource(DataSource dataSource) {

        this.dataSource = dataSource;

    }

    public PlatformTransactionManager getTransactionManager() {

        return transactionManager;

    }

    public void setTransactionManager(PlatformTransactionManager transactionManager) {

        this.transactionManager = transactionManager;

    }

    public TransactionTemplate getTransactionTemplate() {

        return transactionTemplate;

    }

    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {

        this.transactionTemplate = transactionTemplate;

    }

   public void transactionOpen(){

       transactionTemplate.execute(new TransactionCallback(){

        @Override

        public Object doInTransaction(TransactionStatus arg0) {

            // TODO Auto-generated method stub

            //获取数据库链接

            Connection con=DataSourceUtils.getConnection(dataSource);

            try{

                Statement st=con.createStatement();

                st.execute("insert into tb_user (id,name,age) values('5','jj','14')");

            }catch(Exception e){

                transactionManager.rollback(arg0);

                System.out.println("插入操作执行失败");

                e.printStackTrace();

            }

            return null;

        }

       });

   }

}

Manager类测试

Resource resource = new ClassPathResource("applicationContext.xml");            //装载配置文件

            BeanFactory factory = new XmlBeanFactory(resource);

            TranscationExample  trans=(TranscationExample)factory.getBean("transactionExample");

            trans.transactionOpen();

声明式事务管理

在Spring中常用TransactionProxyFactoryBean完成声明式事务管理。

<?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-3.0.xsd">

     <!-- 配置数据源 -->

 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

 <property name="driverClassName">

 <value>oracle.jdbc.driver.OracleDriver</value>

 </property>

 <property name="url">

 <value>jdbc:oracle:thin:@127.0.0.1:1521:orcl</value>

 </property>

 <property name="username">

 <value>system</value>

 </property>

 <property name="password">

 <value>guoyanan</value>

 </property>

 </bean>

    <!-- 定义事务管理器 -->

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

    <property name="dataSource">

    <ref bean="dataSource"/>

    </property>

    </bean>

    <!-- 定义TransactionProxy -->

    <bean id="transactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

    <property name="transactionManager">

    <ref local="transactionManager"/>

    </property>

    <property name="target">

    <!-- 以内部类的形式指定代理对象 -->

    <bean id="UserDao" class="com.US.UserDao">

    <property name="dataSource">

    <ref local="dataSource"/>

    </property>

    </bean>

    </property>

    <property name="proxyTargetClass" value="true"/>

    <property name="transactionAttributes">

    <props>

    <!-- 通过正则表达式匹配事务性方法，并指定方法的事务属性，即代理

    对象中只要是以add开头的方法名必须运行在事务中 -->

    <prop key="inser*">PROPAGATION_REQUIRED</prop>

    </props>

    </property>

    </bean>

    </beans>

UserDao类代理对象

public class UserDao extends JdbcDaoSupport {

    //添加数据

    public void inserUser(User user){

        //执行添加的sql语句

            String sql="insert into tb_user(id,name,age) values ('"+user.getId()+"','"+user.getName()+"','"+user.getAge()+"')";

            //执行添加方法

            getJdbcTemplate().execute(sql);

    }

}

Manager类的main执行方法

public static void main(String[] args){

         Resource resource = new ClassPathResource("applicationContext.xml");            //装载配置文件

            BeanFactory factory = new XmlBeanFactory(resource);

            UserDao  userdao=(UserDao)factory.getBean("transactionProxy");

            User user=new User();

            user.setId(7);

            user.setName("ll");

            user.setAge("17");

            //执行添加方法

            userdao.inserUser(user);

        System.out.println("OK");

    }

应用jdbcTemplate操作数据库

JdbcTemplate类是Spring的核心类之一，可以在org.springframework.jdbc.core包中找到。该类在内部已经处理了数据库资源的建立和释放，避免一些常见的错误。

JdbcTemplate中常用的数据查询方法

方法名称    说明

Int  QueryForInt(String sql)    返回查询的数量

Int  QueryForInt(String sql,Object[]  args)

Long QueryForLong(String sql)    返回查询信息的数量

Long QueryForLong(String sql,Object[] args)

Object  QueryForObject(String sql,Class  type)    返回满足条件的查询对象

Object  QueryForObject(String sql,Class  type,object args)

List  QueryForList(String sql)    返回对象List集合

List  QueryForList(String sql,Object[] args)    

配置JdbcTemplate和数据源

    <!-- 配置数据源 -->

 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

 <property name="driverClassName">

 <value>oracle.jdbc.driver.OracleDriver</value>

 </property>

 <property name="url">

 <value>jdbc:oracle:thin:@127.0.0.1:1521:orcl</value>

 </property>

 <property name="username">

 <value>system</value>

 </property>

 <property name="password">

 <value>guoyanan</value>

 </property>

 </bean>

    <!-- 配置jdbcTemplate -->

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

    <property name="dataSource">

    <ref local="dataSource"/>

    </property>

     </bean>

Main测试方法

Resource resource = new ClassPathResource("applicationContext.xml");            //装载配置文件

            BeanFactory factory = new XmlBeanFactory(resource);

            JdbcTemplate  jdbc=(JdbcTemplate)factory.getBean("jdbcTemplate");

            jdbc.update("insert into tb_user (id,name,age) values('8','jj','14')");

最新文章

  1. 基于dubbo的分布式项目实例应用
  2. 【转载】cmake编写
  3. Ios(ipad iphone) 支持字体一览
  4. javascript cookie 操作
  5. 14.8.1 Creating InnoDB Tables 创建InnoDB 表
  6. 常用的用户状态命令包括：whoami、id、groups、newgrp 等
  7. STL insert()使用
  8. 各种电脑进入BIOS快捷键
  9. C#第一课
  10. 2019春招——Vivo大数据开发工程师面经
  11. 逻辑回归 vs 决策树 vs 支持向量机（I）
  12. Python基础(一)常用函数
  13. Python变量访问权限控制
  14. python并发编程之进程池，线程池concurrent.futures
  15. U811.1接口EAI系列之二--生成销售出库单调用U8的EAI通用处理方法--PowerBuilder语言
  16. python 采坑总结 调用键盘事件后导致键盘失灵的可能原因
  17. like模糊查询
  18. Swift1.2与Xcode6.3 beta
  19. Android中关于JNI 的学习（五）在C文件里使用LogCat
  20. angular-使用定时器调后台接口

热门文章

  1. PyQt5 Function Parameter Declaration
  2. Lua基本函数库 【转】
  3. Unity3D占用内存太大怎么解决呢?
  4. PHP SOCKET编程 .
  5. MS SQL 分类汇总参数 grouping(**)=1 rollup cubt
  6. python学习 01 变量
  7. Openstack(Kilo)安装系列之环境准备（一）
  8. 地形混合shader
  9. z-index随笔
  10. RedisTemplate访问Redis数据结构（介绍和常用命令）