当前位置:  编程技术>综合

[1]spring小结二

五、Spring数据库操作
    1.Spring+JDBC
        （1）特点
            静态代码+动态变量 = jdbc编程。在spring中动态变量可以用注入的形式给予，这样的编程方式适合包装成模版，
            静态代码构成了模版，而动态变量则是需要传入的参数.
        （2）引入DataSource
            在spring中注入DataSource，一般采用c3p0
        （3）核心类JdbcTemplate
            * 它是基于模版的设置
            * 完成了资源的创建和释放的工作
            * 简化为我们对JDBC的操作
            * 完成了对JDBC的核心流程的工作，包括SQL语句的创建和执行
            * 仅需要传递DataSource就可以把它实例化
            * JdbcTemplate只需要创建一次
            * JdbcTemplate是线程安全类
        （4）使用JdbcTemplate
            在Dao类中，用JdbcTemplate作为属性，用spring对JdbcTemplate进行注入.
            再对jdbcTemplate进行DataSource注入.
        （5）继承JdbcDaoSupport
            在Dao类中，继承JdbcDaoSupport，因为JdbcDaoSupport已经有了jdbcTemplate的引用，所以
            只要继承jdbcDaoSupport就相当于有了jdbcTemplate属性.
        （6）使用properties文件
            <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
                <property name="locations">
                    <list>
                        <value>jdbc.properties</value>
                    </list>
                </property>
            </bean>
            或者
            <context:property-placeholder location="classpath:jdbc.properties" />    
            jdbc.properties文件中配置连接信息
                jdbc.driverclass=com.mysql.jdbc.Driver
                jdbc.url=jdbc:mysql://localhost:3306/databasename
                jdbc.username=root
                jdbc.password=root
                
                c3p0.pool.size.max=10
                c3p0.pool.size.min=2
                c3p0.pool.size.ini=3
                c3p0.pool.size.increment=2
        （7）RowMapper的使用
            * 由来：    在jdbc的操作中，有很多情况下是要将ResultSet里的数据封装到一个持久化Bean里，再把持久化
                    Bean封装到集合中，这样会造成大量的代码的重复，不利于代码重用.而RowMapper正好解决这个问题.
            * 使用：
                首先，写一个类实现RowMapper接口
                public class AccountMapper implements RowMapper {
                    public Object mapRow(ResultSet rs, int rowNum) throws SQLException{
                        Account account = new Account();
                        account.setAccountid(ts.getString("accountid"));
                        account.setBalance(rs.getDouble("balance"));
                        return account;
                    }
                }
                其次，在回调接口中，作为参数进行传入即可
                    this.getJdbcTemplate().query(sql,new AccountMapper());
        （8）Spring的事务管理器
            * spring事务管理器介绍
                spring没有直接管理事务，而是将管理事务的责任委托给JTA或响应的持久性机制所提供的某个特定平台的事务实现
                org.springframework.jdbc.datasource.DataSourceTransactionManager
                    在单一的JDBC Datasource中的管理事务
                org.springframework.orm.hibernate3.HibernateTransactionManager
                    当持久化机制是hibernate时，用它来管理事务》
                org.springframework.jdo.JdoTransactionManager
                    当持久化机制是Jdo时，用它来管理事务
                org.springframework.transaction.jta.JtaTransactionManager
                    使用一个JTA实现来管理事务，在一个事务跨越多个资源时必须使用
                org.springframework.orm.ojb.PersistenceBrokerTransactionManager
                    当apache的ojb用作持久化机制时，用它来管理事务.
        （9）spring事务的配置

            * 以xml配置的形式(***号表示需要引入的名称空间)

	<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:tx="http://www.springframework.org/schema/tx" 
		xmlns:aop="http://www.springframework.org/schema/aop"
		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/tx 
				***			http://www.springframework.org/schema/tx/spring-tx-3.0.xsd 
							http://www.springframework.org/schema/aop 
							http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
		<!-- 配置c2p0数据源 -->
		<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
			<property name="driverClass" value="com.mysql.jdbc.Driver" />
			<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/db" />
			<property name="user" value="root" />
			<property name="password" value="root" />
			
			<property name="maxPoolSize" value="10" />
			<property name=&qu      

      
      
    

      

[2]spring小结一

一、概述
    1. Spring是一个开源框架，其目的是为了解决企业应用开发的复杂性.
    2. Spring功能：使用基本的JavaBean代替EJB，并提供更多的企业应用功能.
    3. 简单说，Spring是一个轻量级的控制反转(IOC)和面向切面(AOP)的容器框架.
二、Spring的jar包和配置文件
    1.Spring的jar包
        （1）spring的核心类库在spring文档的dist下.
        （2）引入的第三方类库在spring文档的lib下.
        （3）常用第三方类库
            * 如果使用了切面编程(AOP)，需要    lib/aspectj/aspectjweaver.jar和aspectjrt.jar
                                    lib/cglib/cglib-nodep-2.1_3.jar
            * 如果使用了@Resource/@PostConstruct/@PreDestroy等注解，需要
                    lib/j2ee/common-annotations.jar
    2.Spring的配置文件
        默认是applicationContext.xml文件.
        但实际工程中，一般建立多个xml文件，在applicationContext.xml中引入.
三、Spring的基本功能
    1.SpringIOC
        * spring的控制反转：把对象的创建、初始化、销毁等工作交给spring容器来做，由spring容器控制对象的生命周期.                
        * spring容器的启动：
            （1）在类路径下寻找配置文件来实例化容器(常用)：
                ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"beans.xml"});
                这种方式需要将spring配置文件放到当前项目的classpath路径下.
            （2）在文件系统路径下寻找配置文件来实例化容器：
                ApplicationContext ac = new FileSystemXmlApplicationContext(new String[]{"d:\\beans.xml"});
            * 配置文件可以有多个，通过String数组传入.
    2.别名
        * 使用别名可以达到，在一个地方命名，多个地方使用不同名字的效果.
        <beans>
            <alias name="person" alias="p"/>
            <bean name="person" class="com.liu.domain.Person"/>
        </beans>
    3.Spring容器内部对象的创建
        （1）使用类构造器实例化（默认是无参数的）    
            <bean id="personService" class="com.liu.bean.impl.PersonServiceImpl"/>
        （2）使用静态工厂方法实例化（简单工厂模式）
            <bean id="personService" class="com.liu.factory.PersonServiceFactory" factory-method="createPersonService"/>
            工厂类：
                public  class PersonServiceFactory {
                    public static PersonService createPersonService(){
                        return new PersonServiceImpl();
                    }
                }
        （3）注意，初始化bean时机
            * Spring默认在启动时将所有singleton bean提前进行实例化.即作为初始化的一部分.
            * ApplicationContext会自动创建并配置所有的singleton bean.
            * Lazy-init="false"时，spring容器将在启动的时候报错（可以及时发现错误）
            * Lazy-init="true"时，spring容器将在调用该类的时候出错.
    4.Bean的作用域(scope属性)
        （1）singleton(默认值)
            * 在每个spring IoC容器中，一个bean定义只有一个对象实例，即是单例的.
            * 默认情况下Bean节点的lazy-init为false，即容器启动就初始化bean，如果想延迟，可改为true
            * 如果相对所有bean都延迟初始化，可以在根节点Beans设置default-lazy-init="true"
                例如：<beans default-lazy-init="true"..>
        （2）prototype
            * 允许bean可以被多次实例化（使用一次就创建一个实例）.
            * spring不能对prototype bean的整个生命周期负责，这就意味着清楚prototype作用域的对象
                并释放任何prototype bean所持有的昂贵资源都是客户端的责任        
        （3）Request
            在一次Http请求中，一个bean定义对应一个实例；
            即每次Http请求将会有各自的bean实例，它们依据某个bean定义创建而成.
            该作用域仅在基于web的Spring ApplicationContext情形下有效.
        （4）Session
            在一个Http Session中，一个bean定义对应一个实例，该作用域仅在基于web的Spring ApplicationContext情形下有效.
        （5）Global session
            再一个全局的Http Session中，一个bean定义对应一个实例.
            典型情况下，仅在使用portlet context的时候有效.
            该作用域仅在基于web的Spring ApplicationContext情形下有效.
        （6）指定Bean的初始化方法和销毁方法
             * Spring初始化bean或销毁bean时，有时需要作一些处理工作，因此spring可以在创建和拆卸bean的时候调用bean的两个生命周期方.
                  <bean id=“foo” class=“...Foo”
                        init-method=“setup”
                        destory-method=“teardown”/>
            * 当foo被载入到Spring容器中时调用init-method方法.当foo从容器中删除时调用destory-method（scope = singleton有效）
    5.依赖注入（DI）
        （1）使用构造器注入
            * 通过xml的方式注入：
                A:通过参数的顺序：
                    <constructor-arg index="0">
                        <value>张三</value>
                    </constructor-arg>
                    <constructor-arg index="1">
                        <value>56</value>
            

[3]SQL Server Error Log 管理

SQL Server除了每个数据库有Log文件，即LDF文件外，SQL Server自己本身也有一个Error Log，位置存在安装目录下，Widows系统中log文件位于C:\Program Files\Microsoft SQL Server\MSSQL10_50.MSSQLSERVER\MSSQL\Log。

Error log的文件数目可以配置，最多99个，默认6个，文件编号为ERRORLOG.1,2,3,4.....，还有一个文件没有编号，就叫ERRORLOG，这个文件是SQL Server当前的活动日志文件(active log)，这个文件无法删除，其他的都可以删除。也就是说，ERRORLOG文件里是最新的日志信息，其他的文件都是以前的信息。

 

每次SQL Server重启动，所有的ERRORLOG文件要做一次切换，拿6个log文件来说，具体如下：

删除ERRORLOG.6中的所有数据

ERRORLOG.5的数据写入到ERRORLOG.6中

ERRORLOG.4的数据写入到ERRORLOG.5中

ERRORLOG.3的数据写入到ERRORLOG.4中

ERRORLOG.2的数据写入到ERRORLOG.3中

ERRORLOG.2的数据写入到ERRORLOG.1中

ERRORLOG的数据写入到ERRORLOG.1中

重新创建ERRORLOG文件

 

所以，如果SQL Server不重启，ERRORLOG文件就会变得很大，解决办法如下：

1. 如果需要保存就得Error log文件，则先把当前的所有ERRORLOG文件copy到其他存储介质

2. 运行命令:  EXEC sp_cycle_errorlog， 这个命令强制SQL Server做一次Error Log文件的切换

3. 把最大的log 文件删除

 

如果需定期切换error log，一般可使用DBCC errorlog命令在一个sql server的agent job 来完成。

 

create procedure sp_cycle_errorlog 
if (not (is_srvrolemember('sysadmin') = 1))  -- Make sure that it is the sysadmin role to execute the code.
    begin
        raiserror(15247,-1,-1)
 return(1)
    end

dbcc errorlog
return (0)

GO