Spring - 标签 - ISLANDhttps://youngxhui.top/tags/spring/Spring - 标签 - ISLANDHugo -- gohugo.iozh-CNyoungxhui@gmail.com (youngxhui)youngxhui@gmail.com (youngxhui)本作品采用知识共享署名-非商业性使用 4.0 国际许可协议进行许可。Thu, 02 Mar 2017 20:29:13 +0000Spring学习记录(二)https://youngxhui.top/2017/03/spring%E5%AD%A6%E4%B9%A0%E8%AE%B0%E5%BD%95-%E4%BA%8C/Thu, 02 Mar 2017 20:29:13 +0000youngxhuihttps://youngxhui.top/2017/03/spring%E5%AD%A6%E4%B9%A0%E8%AE%B0%E5%BD%95-%E4%BA%8C/ AOP简述

面向切面编程，扩展功能不修改源代码实现。AOP采用横向抽取机制，取代了传统的纵向继承体系重复代码。

AOP底层原理

AOP操作相关术语

  • 链接点：类里面的被增强的方法。
  • 切入点：类里面的增强的方法，在实际操作中，实际增强的方法叫切入点。
  • 通知/增强：增强的逻辑，称为增强，比如扩展日志功能，这个日志功能称为增强。 前置通知：在方法之前执行 后置通知：在方法之后执行 异常通知：出现异之后执行 最终通知：在后置之后执行 环绕通知：在方法之前和之后执行
  • 切面：把增强应用到具体的方法上面，这个过程称为切面。把增强用到切入点的过程。

Spring的AOP操作

在Spring进行aop操作，使用Aspectj框架，这个框架本身不是Spring的一部分，只是一起使用进行AOP操作。

  • 版本在2.0以后支持切点表达式支持。
  • 相关ja包

aopalliance,aspectjweaver,spring-aop,spring-aspects

  • 创建Spring核心配置文件导入AOP约束。
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
  • 常用表达式 通过execution函数表达式实现。

execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

  • execution(* /增强方法的全路径/): *代表任意修饰符，空格后跟随增强方法的全路径。
  • execution(* com.Hello.*):代表该类的所有方法
  • execution(* .(..))
  • execution(* save*(..)) 表示以save开头的方法进行增强。

xml配置代码

<!--1.配置类-->
    <bean id="book" class="aop.Book"/>
    <bean id="myBook" class="aop.MyBook"/>
    <!--2.配置aop操作-->
    <aop:config>
        <!--2.1配置切入点-->
        <aop:pointcut id="pointcut1" expression="execution(* aop.Book.add())"/>
        <!--2.2配置切面-->
        <aop:aspect ref="myBook">
            <aop:before method="before1" pointcut-ref="pointcut1"/>
        </aop:aspect>
    </aop:config>

创建类的对象，在spring的配置文件中开启aop操作。

<aop:aspectj-autoproxy> </aop:aspectj-autoproxy>

通过注解来实现。

在增强类上 @Aspect注解类，@Before注解方法(前置通知)。

  • @Before
  • @AfterReturning
  • @Around
  • @AfterThrowing
  • @After

Spring的JdbcTemplate操作

Spring在dao层，使用JdbcTemplate，Spring为各种支持的持久化技术，都提供了简单操作的模板和回调。

ORM持久化技术 模板类
JDBC org.springframework.jdbc.core.JdbcTemplate
Hibemate5.0 org.springframework.orm.hibernate5.HibernateTemplate
IBatis(MyBatis) org.springframework.orm.ibatis.sqlMapClientTempate
JPA org.springframework.orm.jpa.JpaTempate

都是对数据库进行crud操作。

  • 导入JdbcTemplate相关jar包

spring-jdbc spring-tx

  • 创建对象设置数据库信息，比如：加载驱动，设置url，用户名，密码等。 实例代码
DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUsername("root");
        dataSource.setUrl("jdbc:mysql://localhost:3306/JdbcDemo");
        dataSource.setPassword("12qwaszx");
  • 创建 JdbcTemplate模板对象，设置数据源。
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
  • 调用JdbcTemplate对象里面的方法实现操作。
    String sql = "INSERT INTO jdbcTest (id, name, password) VALUES (?,?,?)";
    jdbcTemplate.update(sql, "1", "lucy", "1234");
    String sql = "UPDATE jdbcTest\n" +
                "SET name = ?\n" +
                "WHERE id=?";
    jdbcTemplate.update(sql,"cat","1");
    String sql = "DELETE FROM jdbcTest WHERE name=?";
    jdbcTemplate.update(sql,"cat");

JdbcTemplate实现查询，有接口RowMapper, JdbcTemplate针对这个接口美欧提供实现类，等到不同的类型数据需要自己封装

  • 查询一个值
    //查询返回某值
    String sql1="SELECT count(*) FROM jdbcTest";
    int count=template.queryForObject(sql1,Integer.class);
  • 返回对象
    //查询返回对象
    String sql2 = "select * from jdbcTest where name=?";
    //调用jdbcTemplate方法
    User user=template.queryForObject(sql2,new MyRowMapper() , "tom");
    System.out.println(user);

要自己封装这个类 其中querForObject这个方法的第二个值为RowMapper，需要自己进行封装。 MyRowMapper.class

class MyRowMapper implements RowMapper<User> {
    @Override
    public User mapRow(ResultSet resultSet, int i) throws SQLException {
        //从结果集里面把数据得到
        String username = resultSet.getString("name");
        String password = resultSet.getString("password");
        //把数据封装到对象里面
        User user = new User();
        user.setName(username);
        user.setPassword(password);
        return user;
    }
}
  • 返回list集合
        String sql3 = "select * from jdbcTest";
        List<User> list = template.query(sql3, new MyRowMapper());
        System.out.println(list);
  1. 导入jar包 c3p0和mchange-commons-java
  2. 在Spring的配置文件配置连接池
  3. 在dao中使用
  1. 在Service中注入Dao。
  2. 在Dao中注入jdbc模板。
  3. 在模板中注入连接池。
  4. 在连接池中写配置。

示例代码

UserService.class

package com.c3p0;

/**
 * Created by youngxhui
 * Time is 17-2-19.
 */
public class UserService {

    private UserDao userDao;

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

UserDao.class

package com.c3p0;

import org.springframework.jdbc.core.JdbcTemplate;

/**
 * Created by youngxhui
 * Time is 17-2-19.
 */
public class UserDao {
    private JdbcTemplate jdbcTemplate;
    public void add() {

        String sql="INSERT INTO jdbcTest (id, name, password) VALUES (?,?,?)";
        jdbcTemplate.update(sql, 5, "lili", "123456");

    }

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

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

    <!--配置c3p0的连接池-->
    <bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/JdbcDemo"/>
        <property name="user" value="root"/>
        <property name="password" value="12qwaszx"/>
    </bean>

    <bean id="userService" class="com.c3p0.UserService">
        <property name="userDao" ref="userDao"/>
    </bean>

    <bean class="com.c3p0.UserDao" id="userDao">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>

    <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
        <property name="dataSource" ref="comboPooledDataSource"/>
    </bean>
</beans>

Spring事务管理

事务是访问数据库的一个操作序列，数据库应用系统通过事务集来完成对数据库的存取。事务的正确执行使得数据库从一种状态转换成另一种状态。

  • 原子性（atomicity）
  • 一致性（consistency
  • 隔离性 （isolation）
  • 持久性（durability）

spring对事务管理的两种方式

  • 编程式事务管理(不用)
  • 声明式事务管理
    • 基于xml配置文件实现
    • 基于注解实现

Spring事务管理高层抽象主要包含3个接口

  • PlatformTransactionManager事务管理器
  • TransactionDefinition事务定义信息
  • TransactionStatus事务具体运行状态

PlatformTransactionManager针对不同的dao层，提供了不同的接口实现类

事务 说明
org.springframework.idbc.datasource.DataSourceTransactionManager 使用Spring JDBC或iBatis进行持久化数据时使用
org.springframework.orm.hibernate5.HibernateTransactionManger 使用Hibernate5.0版本进行持久化数据时使用
org.springframework.orm.jpa.JpaTransactionManager 使用JPA进行持久化
org.springframework.jdo.JdoTransactionManager 当持久化机制是Jdo时使用
org.springframework.transaction.ita.JtaTransactionManager 使用一个JTA实现来管理事务，在一个事务跨越多个资源时必须使用
]]>Spring学习(一)https://youngxhui.top/2017/02/spring%E5%AD%A6%E4%B9%A0-%E4%B8%80/Wed, 08 Feb 2017 10:54:06 +0000youngxhuihttps://youngxhui.top/2017/02/spring%E5%AD%A6%E4%B9%A0-%E4%B8%80/Spring学习笔记，仅供自己参考。

概述

  1. Spring是开源的轻量级框架。
  2. Spring核心主要为两部分： (1).AOP:面向切面编程 (2).IOC：控制反转： 把对象的创建不是通过new的方式实现，而是交给spring配置创建类对象
  3. Spring是一站式框架。 Spring在JavaEE三层结构中，每一层都提供不同的解决技术。
  • web层：SpringMVC
  • service层：Spring的ioc
  • dao层：Spring的jdbcTemplate
  1. Spring版本：4.x

接口

  • 用于沟通的中介勿的抽象化。
  • 对外声明。
  • Java 8中接口可以拥有方法体。

面向接口编程

  • 结构设计中，分清层次及调用关系，每层只能向外提供一组功能接口，更层次仅依赖接口而非实现类。
  • 接口实现的变动不影响各层的调用。
  • 隐藏具体实现和实现多态性的组件。

IOC 控制反转

控制权的转移，应用程序本身不负责依赖对象的创建和维护，而是由外部容器负责创建和维护。 把对象的创建交给spring进行管理

  • IOC的基于配置文件方式
  • IOC的注解方式
  1. xml的配置文件
  2. dom4j解决xml
  3. 工厂设计模式
  4. 反射
  1. 导入jar包
  • 核心jar包 Beans Core Context, SpEL
  • 支持日志输出的jar包
  1. 创建类，在类里面创建方法
  2. 创建spring的配置文件，配置创建类
  • 建议放到src下面
  1. 测试对象创建
  • 使用类的无参构造(主要使用方式)
  • 静态工厂创建
  • 实例工厂创建
  • id属性 起名称，id的属性值可以是任意命名，但是不能包含特殊符号
  • class属性 创建对象所在类的全路径
  • name属性 功能和id属性是一样的，但是name属性可以包含特殊符号。
  • scope属性 singleton:默认值，单例对象。 prototupe:多例。 request:创建了对象，把对象放到request域里面。 session:创建对象，把对象放到session里面。 globalSession:创建对象，把对象放到globalSession里面。
  • 代码里面的特殊标记，使用注解可以完成功能。
  • 注解写法@注解名称(属性名称=属性值)。
  • 注解使用在类上面，方法上面和属性上面。

在xml需要配置一下

 <context:component-scan base-package="com.young.anno"/>
  • Component – 在Spring中提供的@Component三个衍生注解
    • @Controller WEB层
    • @Service 业务层
    • @Repository 持久层 这四个注解目前的功能是一样的，都是创建对象。
@Component(value = "user")
public class User {
    public void add(){
        System.out.println("add....");
    }
}
  • Scope 用于单例与多例等配置,写在Component的下面。
@Component(value = "user")
@Scope(value = "prototype") 
public class User {
    public void add(){
        System.out.println("add....");
    }
}

  • Autowired 注入属性

  • Resource name属性写创建dao对象的value值

DI 依赖注入

创建对象并且组装对象之间的关系

采用constructor-arg来进行,name和value进行对构造器的值进行注入。

<bean id="preperty" class="com.young.property.PrepertyDemo1">
        <constructor-arg name="username" value="zhangsan"/>
</bean>

使用property标签进行注入，name定义类里面定义的属性的名称，value设置具体的值

<bean id="book" class="com.young.property.Book">
        <property name="bookname" value="one"/>
</bean>
  • spring框架只支持set方法注入和构造器注入
  • 创建service类dao类
  • 在service把dao作为类型属性
  • 生成dao类型的set方法
  • UserService.java
public class UserService {
    private UserDao userDao;
    public void add(){
        System.out.println("service");
        userDao.add();
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}
  • 配置文件
    <bean id="service" class="com.young.ioc.UserService">
        <!--不能写value属性，要写ref,dao配置bean标签的id值-->
        <property name="userDao" ref="userdao"></property>
    </bean>
    <bean id="userdao" class="com.young.ioc.UserDao">
  1. Autowired
@Service(value = "userservice")
public class UserService {

    @Autowired
    private UserDao userDao;

    public void add(){
        System.out.println("service");
        userDao.add();
    }
}
  1. Resure

UserDao.java

@Component(value = "userdao")
public class UserDao {
    public void add() {
        System.out.println("UserDao");
    }
}
  • 数组
<!--数组类型-->
        <property name="args">
            <list>
                <value>小马</value>
                <value>小宋</value>
                <value>小王</value>
                <value>小李子</value>
            </list>
        </property>
  • list类型
    <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
            </list>
    </property>
  • map类型
    <property name="map">
            <map>
                <entry key="a" value="张三"/>
            </map>
    </property>
  • properties
    <property name="properties">
            <props>
                <prop key="name">root</prop>
            </props>
    </property>
比较项 xml 注解
添加 <Bean id="" class=""/> @Component
多例/单例 <Bean scope="prototype/>" @Scope
对象类型注入 <bean id="" class=""> <property name=""ref=""></property></bean> @Resource

案例：

BookDao.java

public class BookDao {
    public void book(){
        System.out.println("bookDao");
    }
}

OrderDao.java

public class BookDao {
    public void book(){
        System.out.println("bookDao");
    }
}

BookService.java

public class BookService {

    @Resource(name = "bookDao")
    private BookDao bookDao;
    @Resource(name = "ordlerDao")
    private OrderDao ordersDao;
    
    public void service(){
        System.out.println("service");
        bookDao.book();
        ordersDao.buy();
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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"
       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">
    <context:component-scan base-package="com.young.xmlanno"/>
    <bean id="bookservice" class="com.young.xmlanno.BookService"/>
    <bean id="bookDao" class="com.young.xmlanno.BookDao"/>
    <bean id="ordlerDao" class="com.young.xmlanno.OrderDao"/>
</beans>

测试类


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    @org.junit.Test
    public void testxmlAnno(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bea2.xml");
        BookService bookService= (BookService) context.getBean("bookservice");
        bookService.service();
    }
}
]]>