Spring笔记

来源：互联网发布：程序员社招招聘条件编辑：程序博客网时间：2024/06/09 20:44

Spring核心监听器

<listener>    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener> <context-param>    <param-name>contextConfigLocation</param-name>    <param-value>classpath:applicationContext.xml</param-value></context-param>

Spring之IOC控制反转

Inverse of Control，控制反转，将对象的创建权反转给Spring

入门简例

public Interface UserService{    void sayHello();}public class UserServiceImpl implements UserService{    private UserDao userDao;    public void setUserDao(UserDao userDao){        this.userDao = userDao;    }    public void sayHello{        userDao.sayHello();    }}

public Interface UserDao{    void sayHello();}public class UserDaoImpl implements UserDao{    public void sayHello{        System.out.println("Hello");    }}

<bean id="userService" class="com...UserServiceImpl">    <property name="userDao" value="userDao"/></bean><bean id="userDao" class="com...UserDaoImpl"/>

public void demo(){    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");    UserService userService = (UserService)applicationContext.getBean("userService");    userService.sayHello();}

Spring之工厂

ApplicationContext接口
- ClassPathXmlApplicationContext（加载类路径下的Spring配置文件）
- FIleSystemXMLApplicationContext（加载本地磁盘下的Spring配置文件）

Spring之配置文件

标签描述 id Bean的名字,id唯一约束，不允许特殊字符 name Bean起个名字,没有采用ID约束，允许特殊字符
Spring整合Struts1时,Struts1访问路径以”/”开头 class Bean对象的全路径 scope singleton:单例(默认值)
prototype:多例,Struts2的Action必须多例
request:应用在Web项目中,每次HTTP请求都会创建一个新的Bean
session:应用在Web项目中,同一个HTTP Session共享一个Bean
globalsession:应用在Web项目中,多服务器间的Session,单点登录 init-method bean载入容器时调用init-method指定方法 destroy-method bean从容器中删除的时候调用destroy-method指定的方法

<bean id="userService" class="com...UserServiceImpl" scope="singleton" init-method="init" destroy-method="destroy"/>

public class UserServiceImpl implements UserService{    public void sayHello(){        System.out.println("Hello");    }    public void init(){        System.out.println("init-method调用");    }    public void destroy(){        System.out.println("destroy-method调用");    }}

Spring之配置文件分开管理

主配置文件包含其他配置文件

<import resource="com/../applicationContext2.xml"/>

工厂创建时

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");

Spring之依赖注入

1.属性setter方法注入

private UserDao userDao;public void setUserDao(UserDao userDao){    this.userDao = userDao;}

<bean id="userService" class="com...UserServiceImpl">    <property name="userDao" ref="userDao"/></bean><bean id="userDao" class="com...UserDaoImpl"/>

private String username;public void setUsername(String username){    this.username = username;}

<bean id="userService" class="com...UserServiceImpl">    <property name="username" value="某某某"/></bean>

2.构造函数注入

public class User{    private String username;    private String password;    private Linkman linkman;    public User(String username,String password){        this.username = username;        this.password = password;    }}

<bean id="user" class="com...User">    <constructor-arg name="username" value="某某某"/>    <constructor-arg name="password" value="******"/></bean>

<bean id="user" class="com...User">    <constructor-arg index="0" value="某某某"/>    <constructor-arg index="1" value="******"/></bean>

3.p名称空间注入

<bean id="user" class="com...User" p:username="某某某" p:password="******" p:linkman-ref="xxx"/>

4.SpEL注入

Spring表达式语言的使用

5.集合的注入

List集合

<bean id="user" class="com...User">    <property name="list">        <list>            <value>aaa</value>            <value>bbb</value>            <value>ccc</value>        </list>    </property></bean>

Set集合

<property name="set">    <set>        <value>aaa</value>        <value>bbb</value>        <value>ccc</value>    </set></property>

Map结婚

<property name="map">    <map>        <entry key="aaa" value="111">        <entry key="bbb" value="222">        <entry key="ccc" value="333">    </map></property>

properties属性文件

<property name="pro">    <props>        <prop key="aaa">111</prop>        <prop key="bbb">222</prop>        <prop key="bbb">222</prop>    </props></property>

Spring之注解

<!-- 开启组件的扫描 --><context:component-scan base-package="com.xxx.xxx"/>

1.@Component

组件注解,作用在类上

/*组件注解,标记类<bean id="userService" class="com...UserServiceImpl"/> == @Component(value="userService")*/@Component(value="userService")public class UserServiceImpl implements UserService{    public void sayHello(){        System.out.println("Hello");    }}

三个衍生注解,目前功能是一致的

注解描述 @Controller 作用在WEB层 @Service 作用在业务层 @Repository 作用在持久层

2.属性注入的注解

@value，注入普通类型

public class UserServiceImpl implements UserService{    @Value(value="某某某")    private String username;    //注解方式可省略set方法    public void setUsername(String username){        this.username = username;    }    public void sayHello(){        System.out.println("Hello");    }}

@Autowired，按类型自动装配

public class UserServiceImpl implements UserService{    //自动匹配；类型默认注入UserDapImpl实现类    @Autowired    private UserDao userDao;    //若有多个实现类，必须按名称注入    @Autowired    @Qualifier(value="userDao")    private UserDao userDao;    //Java提供的注解@Resource，相当于@AutoWired和@Qualifier一起使用     @Resource(name="userDao")    private UserDao userDao;    public void sayHello(){        System.out.println("Hello");    }}

Bean的作用范围注解，类级别

@Scope(value="singleton")//单例，默认值@Scope(value="prototype")//多例

Bean的生命周期配置，方法级别

@PostConstruct//相当于init-method@PreDestroy//相当于destroy-method

Spring之基于AspectJ的AOP开发

1.术语

术语描述 Joinpoint(连接点) 所谓连接点是指那些被拦截到的点。
在spring中,这些点指的是方法,因为spring只支持方法类型的连接点 Pointcut(切入点) 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义 Advice(通知/增强) 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.
通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能) Introduction(引介) 引介是一种特殊的通知在不修改类代码的前提下,
Introduction可以在运行期为类动态地添加一些方法或Field Target(目标对象) 代理的目标对象 Weaving(织入) 是指把增强应用到目标对象来创建新的代理对象的过程 Proxy（代理）一个类被AOP织入增强后，就产生一个结果代理类 Aspect(切面) 是切入点和通知的结合，以后咱们自己来编写和配置的

public class MyAspect{    public void log(){        System.out.println("===================");    }}

<!-- 切面类配置 --><bean id="myAspect" class="com...MyAspect"/><!-- 配置AOP --><aop:config>    <aop:aspect ref="myAspect">        <!--配置前置之前，方法执行之前，增强的方法会执行-->        <!--切入点的表达式：execution(public void com...UserServiceImpl.save) -->        <aop:before method="log" pointcut="execution(public void com...UserServiceImpl.save())"/>    </aop:aspect></aop:config>

2.切入点的表达式

表达式描述 execution 固定的不能不写 public 可以省略不写 void 返回值可以用*表示任意返回值 com 可以用*代替。如果简写可以用.. 类名可省略部分，如：*ServiceImpl 方法 save*(*),update*(*)等方法参数 save(..)任意参数

execution(* *..*.*ServiceImpl.save*(..))

3.通知的类型

通知类型描述前置(before) 在目标类的方法之前执行最终(after) 在目标类的方法之后执行，如果程序出现了异常，最终通知也会执行后置(after-return) 方法执行后的通知，异常不执行抛出异常(after-throwing) 抛出异常后通知环绕(around) 方法执行前后执行

Spring之注解AOP

<!-- 只有增加以下配置注解方式才能生效 --><aop:aspectj-autoproxy/>

//定义注解方式的切面类@Aspectpublic class MyAspect{    @Before(value="切入点的表达式")    public void log(){        System.out.println("===================");    }}

通知类型描述 @Before 前置通知 @AfterReturning 后置通知 @Around 环绕通知 @After 最终通知 @AfterThrowing 异常抛出通知

@Aspectpublic class MyAspect{    @Before(value="MuAspect.fn()")    public void log(){        System.out.println("===================");    }}//自动定义切入点@Pointcut(value="切入点的表达式")public void fn(){}

Spring之声明式事务

1.配置文件方式

<!-- 配置事务管理器 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">    <property name="dataSource" ref="dataSource"/></bean><!-- 配置事务增强 --><tx:advice id="txAdvice" transaction-manager="transactionManager">    <tx:attributes>        <!--            name        ：绑定事务的方法名，可以使用通配符，可以配置多个。            propagation ：传播行为            isolation   ：隔离级别            read-only   ：是否只读            timeout     ：超时信息            rollback-for：发生哪些异常回滚.            no-rollback-for：发生哪些异常不回滚.         -->        <!-- 哪些方法加事务 -->        <tx:method name="sayHello" propagation="REQUIRED"/>    </tx:attributes></tx:advice><!-- 配置AOP切面产生代理 --><aop:config>    <aop:advisor advice-ref="myAdvice" pointcut="execution(* *..*.*ServiceImpl.save*(..))"/></aop:config>

传播行为描述 PROPAGATION_REQUIRED A中有事务,使用A中的事务.如果没有，B就会开启一个新的事务,将A包含进来.(保证A,B在同一个事务中)，默认值！！ PROPAGATION_SUPPORTS A中有事务,使用A中的事务.如果A中没有事务.那么B也不使用事务. PROPAGATION_MANDATORY A中有事务,使用A中的事务.如果A没有事务.抛出异常. PROPAGATION_REQUIRES_NEW（记） A中有事务,将A中的事务挂起.B创建一个新的事务.(保证A,B没有在一个事务中) PROPAGATION_NOT_SUPPORTED A中有事务,将A中的事务挂起. PROPAGATION_NEVER A中有事务,抛出异常. PROPAGATION_NESTED（记）嵌套事务.当A执行之后,就会在这个位置设置一个保存点.如果B没有问题.执行通过.如果B出现异常,运行客户根据需求回滚(选择回滚到保存点或者是最初始状态)

2.注解方式

<!-- 配置事务管理器 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">    <property name="dataSource" ref="dataSource"/></bean><!-- 开启注解事务 --><tx:annotation-driven transaction-manager="transactionManager"/>

//开启事务,所有方法都有事务@Transactionalpublic class UserServiceImpl implements UserService{    public void sayHello(){        System.out.println("Hello");    }}

public class UserServiceImpl implements UserService{    //当前方法开启事务    @Transactional    public void sayHello(){        System.out.println("Hello");    }}

阅读全文

0 0