javaee之spring框架总结

JavaEE PV:

前言

spring作为目前最流行，应用最广泛的后端框架，它有着许多优点与特色，比如应用它IOC（控制翻转）的功能以及spring内部的封装，可以与hibernate，struts进行整合，这里只是简单的介绍其主要功能。

spring

IOC

IOC内部原理

IOC内部使用了映射的原理：

<bean id = "userService" class="cn.itcast.UserService"/>

内部原理如下：

//解析dom4j解析xml文件得到class属性值
String classValue = "class属性值";
//使用反射创建类对象
Class clazz = Class.forName(classValue);
//创建类对象
UserService service = clazz.newInstance();
return service;

Bean实例化

类的无参构造方式

<bean id="user" calss="cn.itcast.ioc.User"></bean>

类的静态工厂方法

类方法：

public class Bean2Factory{
    public static Bean2 getBean2(){
        return new Bean2();
    }
}

配置文件：

<bean id="bean2" class="cn.itcast.bean.Bean2Factory" factory-method="getBean2">

类的实例工厂方法

类方法：

public class Bean3Factory{
    public Bean3 getBean3(){
        return new Bean3();
    }
}

配置文件：

<bean id="bean3Factory" class="cn.itcast.bean.Bean3Factory"></bean>

<bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3">

获取实例化对象

//加载配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

//获取实例
User user = (User) context.getBean("user");

Bean标签的常用属性

  1. id属性：对这个bean的属性名，获取该bean的实例时所需的名字。
  2. class属性：创建对象所在类的全路径。
  3. name属性：功能与id属性一样，id属性不能包含特殊字符，但是在name属性值里面可以包含特殊字符。
  4. scope属性：单实例与否。
    1. singleton：默认值，单实例
    2. prototype：多实例

属性注入

使用构造函数注入

bean：

public class PropertyDemo1{
    pubcli PropertyDemo1(String username){
        this.username= username;	
    }
}

配置文件：

<bean id="demo" class="cn.itcast.property.PropertyDemo1">
    <construct-arg name="username" value="谁谁谁"></construct-arg>
</bean>

调用：

ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

PropertyDemo1 demo = (demo) context.getBean("demo");

System.out.println(demo.username);

使用set方法注入

bean：

class setBookname{
    private String bookname;
    public void setBookname(String bookname){
        this.bookname = bookname;
    }
}

配置文件：

<bean id="book" class="cn.itcast.property.Book">
    <property name="bookname" value="嘿嘿嘿"></property>
</bean>

调用：

ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

setBookname book = (book) context.getBean("book");

System.out.println(book.bookname);

注入对象类型属性

UserDao：

public class UserDao{
    public test(){
        System.out.print("test...");
    }
}

UserService：

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

配置文件：

<bean id="userDao" class="cn.itcast.ioc.UserDao"></bean>

//id为类中的属性名
//ref值与生成的bean的id值相同
<bean id="userService" class="cn.itcast.ioc.UserService">
    <property name="userDao" ref="userDao"></property>
</bean>

调用：

ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

UserService userService = (UserService) context.getBean("userService");

userService.userDao.test();

注入数组，list集合，map集合，properties类型属性

<bean id="person" class="cn.itcast.property.Person">
    <!-- 数组 -->
    <property name="arrs">
        <list>
            <value>小王</value>
            <value>小马</value>
            <value>小宋</value>
        </list>
    </property>
    
    <!-- list -->
    <property name="list">
        <list>
            <value>小奥</value>
            <value>小金</value>
            <value>小普</value>
        </list>			
    </property>
    
    <!-- map -->
    <property name="map">
        <map>
            <entry key="aa" value="lucy"></entry>
            <entry key="bb" value="mary"></entry>
            <entry key="cc" value="tom"></entry>
        </map>
    </property>
    
    <!-- properties -->
    <property name="properties">
        <props>
            <prop key="driverclass">com.mysql.jdbc.Driver</prop>
            <prop key="username">root</prop>
        </props>
    </property>
</bean>

IOC注解方式

  1. 在spring配置文件中引入约束：

    xmlns:context=”http://www.springframework.org/schema/context“ xsi:schemaLocation=”
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd“

  2. 在配置文件中开启注解扫描

    //base-package：需要扫描注解的包
    <context:component-scan base-package=”cn.itcast”>

  3. 创建注解对象
    在bean中类的上方加上注解：@Component(value="...")

bean：

@Component(value="user") //等价于<bean id="user" class="...">
public class User{
    public test(){
        System.out.println("got it!");	
    }
}

调用：

public class test(
    ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

    User user = (User) context.getBean("user");
    user.test();
    //got it!
}

可以了解的是，spring提供了4个注解关键字来实例化bean，其中后3个是Componnet的衍生：

  • @Component:都可以使用
  • @Controller: web层
  • @Service: 业务层
  • @Repository: 持久层

注解确定单、多实例

@Scope(value="prototype") //多实例
@Scope(value="singleton") //单实例

注解注入属性

注入基本类型

@Value(value)

bean:

public class test{
    @Value("谁谁谁")
    private	String username;
    @Value(123)
    private int userid;
}

不过我们想向本类中注入值的情况比较少，掌握即可

注入属性对象类型

  • @Autowired:自动检测属性并注入，前提是这个属性对象已经通过spring创建了对象实例，配置文件方式或注释方法都可以。
  • Resource(name=”对象名”)，对象名是通过spring创建的实例id值或name值

  1. 创建属性实例

    @Component(value=”userDao”)
    class userDao{

    }

  2. 注入属性的两种方式

    @Autowired
    private UserDao userDao;

    @Resource(name=”userDao”)
    Private UserDao userDao;

配置文件与注解混合使用

可以在配置文件中声明对象的属性类，然后在对象中通过注解注入属性。

配置文件：

<bean id="bean0" class="...">
<bean id="bean0" class="...">
<bean id="bean0" class="...">

类：

@Resource(name="bean0");
private Bean0 bean0;

@Resource(name="bean1");
private Bean0 bean1;

spring中的AOP

名词解释

  • Joinpoint(连接点)：类里面可以被增强的方法，这些方法被称为连接点。
  • Ponitcut(切入点)：所谓切入点是指我们要对哪些Joinpoint进行拦截。
  • Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
  • Aspect(切面): 是切入点和通知（引介）的结合
  • 增强：增强的逻辑，成为增强，包含以下类型：
    • 前置通知：在方法之前执行
    • 后置通知：在方法之后执行
    • 异常通知：在方法出现异常时执行
    • 最终通知：在后置通知之后执行
    • 环绕通知：在方法之前和之后执行

配置文件

  1. 引入xml命名空间

    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd

  2. 使用表达式配置切入点(实际增强的方法)

表达式：

execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
  • execution(* cn.itcast.aop.Book.add(…))
  • execution(* cn.itcast.aop.Book.*(..))
  • execution(* .(..))
  • 匹配..开头的方法 execution(* save*(..))

AspectJ的aop操作

  • AspectJ不是spring的一部分，和spring一起使用aop操作。
  • spring2.0以后新增了对AspectJ的支持。
  • AspectJ可以用配置文件或注释文件。

  1. 配置对象

  2. 配置aop操作

    aop:config
    //配置切入点
    <aop:pointcut expression=”execution(* cn.itcast.aop.Book.*(..))” id=”pointcut1”>

    //配置切面，将增强用到切入点上
    <aop:aspect ref=”myBook”>
    <aop:before method=”before1” pointcut-ref=”pointcut”/>
    aop:aspect

值得注意的是：

  1. aop:point标签是在配置切入点，即哪些方法需要被增强，其中expression为表达式，id为自定义名称。
  2. aop:aspect标签是在配置切面，即用哪些增强(方法)来增强切入点。
  3. 在aop:aspect内部标签表示的是增强的方式。包含以下标签：
    1. aop:before 前置通知
    2. aop:after-returning 后置通知
    3. aop:around 环绕通知
    4. aop:after-throwing 异常通知
    5. aop:after 最终通知

AspectJ的注解AOP操作

  1. 创建对象

     <bean id="book" class="cn.itcast.aop.Book"></bean>

  2. 在spring核心配置文件中，开启aop操作

    aop:aspectj-autoproxyaop:aspectj-autoproxy

  3. 在增强类上使用注解完成aop操作

    @Aspect
    public class MyBook{
    @Before(value=”execution(* cn.itcast.aop.Book.*(..))”)
    public void before1(){
    System.out.print(“before……..”);
    }
    }

sping的jdbcTemplate操作

  1. 设置数据库信息

    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName(“com.mysql.jdbc.Driver”);
    dataSource.setUrl(“jdbc.mysql:///database0”);
    dataSource.setUsername(“root”);
    dataSource.setPassword(“root”);

  2. 创建jdbcTemplate对象，设置数据源

    JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

  3. 创建sql语句，并执行jdbcTemplate中的方法

    1. 增加

    String sql = “insert into user value(?,?)”;
    int rows = jdbcTemplate.update(sql,”lucy”,”250”);

    1. 修改

    String sql = “update user set password =? where username=?”;
    int rows = jdbcTemplate.update(sql,”1234”,”lucy”);

    1. 删除

    String sql = “delete from user where username=?”;
    int rows = jdbcTemplate.update(sql,”lucy”);

    1. 查询

    //返回对象
    String sql = “select * from user where username=?”;
    User user jdbcTemplate.queryForObject(sql,new MyRowMapper(),”mary”);
    System.out.println(user);

    //实现RowMapper
    class MyRowMapper implements RowMapper{
    @Override
    public User mapRow(Result re, int num) throws SQLException{
    String username= rs.getString(“username”);
    String password = rs.getString(“password”);

         User user = new User();
     user.setUsername(username);
     user.setPassword(password);
 }

    }

    //返回list
    String sql = “select * from user”;
    List list = jdbcTemplate.query(sql,new MyRowMapper());

    System.out.println(list);

Spring配置c3p0连接池和dao使用jdbcTemplate

因为配置jdbcTemplate数据库的数据库信息实际上还是创建对象，注入属性。所以同样可以用Spring的AOP进行对象的创建。

  1. 导入c3p0以及配合的jarbao

  2. 配置c3p0连接池

  3. dao使用jdbcTemplate

    1. 创建service和dao，配置service和dao对象，并把service注入dao对象
    1. 创建jdbcTemplate对象

    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate){
    this.jdbcTemplate = jdbcTemplate;
    }

    1. 把模板对象注入dao中
    1. 在jdbcTemplate对象里注入dataSource

    private DataSource dataSource;
    privateSQLExceptionTranslator exceptionTranslator;
    private boolean lazyInit = true;

    public void setDataSource(DataSource dataSource){
    this.dataSource = dataSource;
    }

spring的事务管理

xml方式

  1. 在核心配置文件中配置事务管理器

  2. 配置事务增强

    <tx:advice id=”txadvice” transaction-manager=”transactionManager”>
    tx:attributes
    <tx:method name=”account*” propagation=”REQUIRED”/>

    tx:advice

  3. 配置切面

    aop:config
    <aop:pointcut expression=”execution(* cn.itcast.service.OrderService.*(..))” id=”pointcut1”>

    <aop:adviser advice-ref=”txadvice” point=ref=”pointcut1”/>

注解方式

  1. 配置事务管理器

  2. 开启事务注解

    <tx:annotation-driven transaction-manager=”transactionManager”/>

  3. 在需要使用事务的方法所在类上面添加注解

    @Transactional
    public class ordersService{

    }

Last

这里的内容多是视频教学笔记中的内容加上我自己的理解，只是不是很深，只是一个最基本的用法，并且省去了配置环境的问题，比如导入jar包等等，这里面可能有很多错误或不足，因为我也是才开始接触。加油加油！

Powered by Hexo and Hexo-theme-hiker

Copyright © 2019 - 2024 My Wonderland All Rights Reserved.

UV : | PV :