Spring 笔记总结

1、Spring框架的核心是提供一个容器（BeanFactory 或 ApplicationContext），提供以下功能：

　　1）创建和销毁组件对象，类似“工厂类”

　　2）采用不同的模式创建对象

　　3）IOC

　　4）AOP

2、Bean组件配置

　　<bean id="标识符" class="完整类路径" scope="type" init-method="方法名" destroy-method="方法名"/>

　　　　type:1）singleton：单例模式，在容器实例化时创建

　　　　　　 2）prototype：在调用getBean()时创建

　　　　指定销毁方法是在容器关闭时触发，只适用于singleton

　　使用时：

　　　　ApplicationContext ac = new ClassPathXmlApplicationContext("paw/applicationContext.xml");

　　　　Bean bean = (Bean)ac.getBean("beanid");

3、Spring IOC

　　将对象关系的指定，对象创建，初始化和销毁等逻辑交给Spring负责

4、DI

　　Spring采用DI技术实现IOC控制思想

　　注入的两种方法：

　　　　1）setter方式注入，使用set方法注入，在<bean>中采用如下描述：

　　　　　　<property name="属性名" ref="注入Bean对象的ID" />

　　　　2）构造方法注入，提供构造方法注入，少用，<bean>中配置：

　　　　　　<constructor-arg index ="参数索引，从0开始计数" ref="注入Bean对象的ID" />

　　Spring中各种类型的数据注入

　　　　1）Bean对象注入

　　　　　　<property name="属性名" ref="注入Bean对象的ID" />

　　　　2）基本数据的注入

　　　　　　<property name="属性名" value="值" />

　　　　3）集合的注入

　　　　　　（1）List Set　　

　　　　　　　　<property name="属性名" >

　　　　　　　　　　<list>

　　　　　　　　　　　　<value>value0</value>

　　　　　　　　　　　　<value>value1</value>

　　　　　　　　　　</list>

　　　　　　　　</property>

　　　　　　<!-- 普通值用<value>标签，对象用<bean>标签：<ref bean="beanid" />，如果是集合，<list> 标签改成 <set> -->

　　　　　　（2）Map　　　　　

　　　　　　　　<property name="属性名" >

　　　　　　　　　　<map>

　　　　　　　　　　　　<entry key="键0" value="值0" />

　　　　　　　　　　　　<entry key="键1" value="值1" />

　　　　　　　　　　</map>

　　　　　　　　</property>

　　　　　　<!-- 普通值用<value>标签，对象用： <entry key="键0" value-ref="beanid" />-->

　　　　　　（3）properties

　　　　　　　　<property name="属性名" >

　　　　　　　　　　<props>

　　　　　　　　　　　　<prop key="键0"> value<prop/>

　　　　　　　　　　　　<prop key="键1"> value<prop/>

　　　　　　　　　　</props>

　　　　　　　　</property>

5、AOP

　　1）aspect：插入的通用处理功能组件

　　2）joinpoint：连接点，aspect插入点

　　3）pointcut：joinpoint组成pointcut

　　4）advice：通知，aspect 和 joinpoint间的发生次序

　　5）target：目标，利用切入点指定的组件和方法

　　6）autoproxy：AOP利用动态代理实现AOP

　　例子：

   <aop:config>
        <aop:aspect id="TestAspect" ref="aspectBean">
            <!--配置com.spring.service包下所有类或接口的所有方法-->
            <aop:pointcut id="businessService" expression="execution(* com.spring.service.*.*(..))" />
            <aop:before pointcut-ref="businessService" method="doBefore"/>
            <aop:after pointcut-ref="businessService" method="doAfter"/>
            <aop:around pointcut-ref="businessService" method="doAround"/>
            <aop:after-throwing pointcut-ref="businessService" method="doThrowing" throwing="ex"/>
        </aop:aspect>
    </aop:config>  

    <bean id="aspectBean" class="com.spring.aop.TestAspect" />
    <bean id="aService" class="com.spring.service.AServiceImpl"></bean>
    <bean id="bService" class="com.spring.service.BServiceImpl"></bean>

　　切入点定义：

　　　　1）方法限定表达式：execution(修饰符（可无） 返回类型 方法名(参数列表)  异常（可无）)

　　　　2）类型限定表达式：with(类型)

　　　　3）Bean名称限定：Bean(id)

　　　　4）args参数限定：args(类型)

6、log4j

　　log4j主要有以下3部分构成

　　　　1）日志器（logger）

　　　　2）输出器（appender）

　　　　3）布局器（格式器，layout）

　　如：

#1. 设置输出级别
log4j.rootLogger=info,myconsole,myfile,dateFile,MAIL

#2. 设置具体的配置信息
log4j.appender.myconsole=org.apache.log4j.ConsoleAppender
log4j.appender.myconsole.target=System.out
log4j.appender.myconsole.layout=org.apache.log4j.PatternLayout
log4j.appender.myconsole.layout.conversionPattern=%d{yyyy-MM-dd HH\:mm\:ss.SSS} %l %m %n 

#2. 设置具体的配置信息(文件中)
log4j.appender.myfile=org.apache.log4j.FileAppender
log4j.appender.myfile.file=d:/log4j.txt
log4j.appender.myfile.layout=org.apache.log4j.PatternLayout
log4j.appender.myfile.layout.conversionPattern=%d{yyyy-MM-dd HH\:mm\:ss.SSS} %l %m %n

#2. 设置具体的配置信息(文件中,每天一个)
log4j.appender.dateFile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.dateFile.File=d\:/my.html
log4j.appender.dateFile.layout=org.apache.log4j.HTMLLayout
log4j.appender.dateFile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c] [%p] - %m%n

#2. 设置具体的配置信息(发送邮件)
log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
#控制当前级别: log4j.appender.MAIL.Threshold=FATAL
log4j.appender.MAIL.bufferSize=100
log4j.appender.MAIL.From=[email protected]
log4j.appender.MAIL.SMTPHost=127.0.0.1
log4j.appender.MAIL.Subject=Log4J Message
log4j.appender.MAIL.To=[email protected]
log4j.appender.MAIL.layout=com.zuxia.test.MyLayoutPattern #此类是用户自定义的哦 重写了HTMLLayout类
log4j.appender.MAIL.layout.ConversionPattern=%d - %c -%-4r [%t] %-5p %c %x - %m%n

　　在log4j.properties如果配置多种输出方式，其均有效　　

　　获取logger时：

　　　　Logger logger = Logger.getLogger(??)

　　　　??在打印日志的时候会显示出来

7、Spring注解配置

　　1）组件扫描：　

　　　　@Component：其他组件

　　　　@Controller：Action组件

　　　　@Service：Service组件

　　　　@Repository：Dao组件

　　注解只能用在类定义前，方法定义前，成员变量定义前，上述注解只是推荐用法

　　2）开启组件扫描方法：

　　　　<context:component-scan base-package="package.path" />

　　4）注入注解，注入标记在成员变量定义前使用

　　　　@Resource：默认按类型匹配注入，如有多个符合要求类型，报错，匹配不唯一，使用名称注入方式

　　　　　　@Resource(name="beanid")

　　　　@Autowired：默认按类型匹配注入，如有多个符合要求类型，则使用名称注入方式

　　　　　　@Autowired

　　　　　　@Qualifier("beanid")

　　5）AOP注解

　　　　（1）开启AOP注解

　　　　　　<aop:aspect-autoproxy />

　　　　（2）使用@component将组件扫描到时Spring容器

　　　　（3）使用@Aspect将组件定义为Aspect组件

　　　　（4）定义方法，在方法前使用@Pointcut定义切入点表达式

　　　　（5）在target前使用@Around，@Before，@AfterReterning，@AfterThrowing，@After

　　例子

package com.bird.service;  

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;  

/**
 * 切面
 * @author Bird
 *
 */
@Aspect
public class MyInterceptor {
    @Pointcut("execution(* com.bird.service.impl.PersonServiceBean.*(..))")
    private void anyMethod(){}//定义一个切入点  

    @Before("anyMethod() && args(name)")
    public void doAccessCheck(String name){
        System.out.println(name);
        System.out.println("前置通知");
    }  

    @AfterReturning("anyMethod()")
    public void doAfter(){
        System.out.println("后置通知");
    }  

    @After("anyMethod()")
    public void after(){
        System.out.println("最终通知");
    }  

    @AfterThrowing("anyMethod()")
    public void doAfterThrow(){
        System.out.println("例外通知");
    }  

    @Around("anyMethod()")
    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("进入环绕通知");
        Object object = pjp.proceed();//执行该方法
        System.out.println("退出方法");
        return object;
    }
}

　　6）常用注解汇总

@Configuration把一个类作为一个IoC容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean。
@Scope注解 作用域
@Lazy(true) 表示延迟初始化
@Service用于标注业务层组件、
@Controller用于标注控制层组件（如struts中的action）
@Repository用于标注数据访问组件，即DAO组件。
@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
@Scope用于指定scope作用域的（用在类上）
@PostConstruct用于指定初始化方法（用在方法上）
@PreDestory用于指定销毁方法（用在方法上）
@DependsOn：定义Bean初始化及销毁时的顺序
@Primary：自动装配时当出现多个Bean候选者时，被注解为@Primary的Bean将作为首选者，否则将抛出异常
@Autowired 默认按类型装配，如果我们想使用按名称装配，可以结合@Qualifier注解一起使用。如下：
@Autowired @Qualifier("personDaoBean") 存在多个实例配合使用
@Resource默认按名称装配，当找不到与名称匹配的bean才会按类型装配。
@PostConstruct 初始化注解
@PreDestroy 摧毁注解 默认 单例  启动就加载
@Async异步方法调用
时间： 2024-11-07 13:15:59

Spring 笔记总结的相关文章

Spring笔记（4）-----&lt;bean&gt;的基本配置

Spring容器成功需要具备的三个条件: 1)Spring框架的类包都已经放在应用程序的类路径下. 2)应用程序为Spring提供了完备的Bean配置信息. 3)Bean的类都已经放在类路径下. Spring启动时读取应用程序的Bean配置信息,在容器中生成一份相应的Bean配置注册表,然后根据这张注册表实例化Bean,装配好Bean的依赖关系,为上层应用提供准备就绪的运行环境. Bean的配置信息是Bean的元数据信息,有4部分: 1)Bean的实现类. 2)Bean的属性信息. 3)Bean

spring笔记（一）

这几日,在看spring框架的知识,了解了一下spring的IoC核心,AOP的概念,然后剩下的其实就是Spring对于其他的java服务的封装:ORM,web, JMS,JMX等. 坦白地说,我并没有完全理解spring的结构,首先它的API,我还不是很清楚,现在能至少做个分类.其次,spring框架和ORM之类的框架在做集成时的编程经验,我还没有. 后面的路要一分为二,继续对于spring底层的细节进行学习和了解,其次对于spring和其他组件整合的知识在实践中学习.看书估计不管用了. sp

Spring笔记（二）:Ioc 之注入与装配

一.Spring依赖注入的原理 二.依赖注入的实现 (一)对象的注入 1.简单属性注入 1)源代码 package main.java.com.spring.ioc.base.dao.impl; import main.java.com.spring.ioc.base.dao.PersonDao; /** * * PersonDiDaoImpl * @title * @desc * @author SAM-SHO * @Dec 28, 2014 */ public class PersonDiD

Spring 笔记

1, 新建包或导入工程错误提示: The type javax.servlet.ServletContext cannot be resolved. It is indirectly referenced from required .class files. 解决方法:在安装的tomcat下的lib目录里面找到servlet-api.jar包,导入项目下的lib文件夹中即可. 2,Could not load the Tomcat server configuration at /Server

Spring笔记1

Spring依赖应用上下文xml文件(beans.xml或ApplicationContext.xml)进行对象定义,完成核心工作.可以在xml文件中import其他的xml文件(如数据库,<import resource="spring/dao/MySQL-datasource.xml"/>).beans为Map<String,Object>结构. AOP即面向切面编程(Aspect Oriented Programming). jdom包用于解析xml文件,

Spring笔记（一）:Ioc 之 Bean的管理

前提: 1.需要 spring.dom4j.junit.commons-logging等的jar包, 配置web.xml,新增 applicationContext.xml 2.Spring主要核心是: 1)控制反转(IOC):以前传统的java开发模式中,当需要一个对象时我们,我们会自己使用new或者getInstance等直接或者间接调用构造方法创建一个对象,而在Spring开发模式中,Spring容器使用了工厂模式为我们创建了所需要的对象,我们使用时不需要自己去创建,直接调用Spring为

spring笔记(三)

Spring 第二天: 1. 代理模式 2. Aop编程 3.Spring对Jdbc的支持 JdbcTemplate工具类 思考: 程序的"事务控制", 可以用aop实现! 即只需要写一次,运行时候动态织入到业务方法上. Spring提供了对事务的管理,开发者只需要按照Spring的方式去做就行. 目标: 1. Spring声明式事务管理 * XML配置 *注解方式 2. Spring与Hibernate整合 3.  SSH整合 1. 程序中事务控制 1.1 环境准备 用户访问->

spring笔记一

Spring最有用的地方就是IOC.虽然代码很简单,但实际上最有用. IoC是什么? Ioc-Inversion of Control,即"控制反转",不是什么技术,而是一种设计思想. 我们在Biz的文件夹下面,创建一个类SpringContext.java public class SpringContext{ private static ApplicationContext ctx;//静态变量 //get()方法 Public static ApplicationContext

Spring笔记3

annotation(注解)(可见Spring_pref,3.11) 加入annotation,需要在beans.xml的<beans>标签加属性xmlns:context="http://www.springframework.org/schema/context",并在<beans>标签辖内加标签<context:annotation-config />.前者是新增的xml的命名空间,后者表示该xml文件的bean有参与注解的.前者属性中,冒号前

Spring笔记2

IOC/DI简介: DI为依赖注入,通常来说bean是自己控制对象的实例化等工作(即依赖关系).但在Spring容器中,创建bean的同时完成了注入依赖关系的工作. IOC为控制反转,其与DI的意义类似,即本来bean自己控制实例化,现在成了创建bean时便完成了实例化等依赖工作,所以称为控制反转. ”依赖注入(DI)背后的基本原理是对象之间的依赖关系(即一起工作的其它对象)只会通过以下几种方式来实现:构造器的参数.工厂方法的参数,或给由构造函数或者工厂方法创建的对象设置属性.因此,容器的工作就