spring框架知识总结

1. spring环境搭建准备

//所有hibernate的lib包

//所有spring的lib包

//mysql驱动包

//日志包

//测试包

* com.springsource.net.sf.cglib-2.2.0.jar

* spring-aspects-4.0.0.RELEASE.jar

//aop包

//jdbc连接包

//jpa连接标准

扫描二维码关注公众号，回复： 6109681 查看本文章

//在web上使用spring的包

2.appllicationContext.xml配置使用

1.创建appllicationContext.xml文件

2.创建IOC容器

ApplicationContext ctx = new ClassPathXmlApplicationContext(“applicationContext.xml”); //FileSystemXmlApplicationContext//ConfigurableApplicationContext--refresh()和close()

3.拿出bean对象

Student student = ctx.getBean(“beanId”);//id/类型名

3.配置bean

1.bean基本结构，属性赋值，特殊数据结构定义

<bean> id=”唯一标识” class=”全类名” //类必须有无参构造器

<property name=”类属性” value=”值”></property> //属性根据set方法注入

<property name=”car” ref=”id”></property> //引用类型传值

<ref bean=”id”/> //ref子节点

</property>

<bean class=”全类名”> //内部bean

</bean>

</property>

<property name=”car.name” value=”aodi”></property> //级联属性赋值

<list> //list/set/array/map属性一样

</list>

<map> //map

</map>

</property>

<property name=”properties”> //properties属性

<props>

</props>

</property>

</bean>

2.构造器赋值，结构单例

<bean> id=”唯一标识” class=”全类名”

<constructor-arg value=”属性” (index=”0”)(type=”java.long.String”)></constructor-arg> //通过构造器注入，标记，类型

<constructor-arg (type=”java.long.String”)>

<value><![CDATA[<shanghai>]]></value> //value子节点，CDATA转译

</constructor-arg>

<constructor-arg><null/></constructor-arg> //赋空值

</bean>

<util:list id=”cars”> //单例集合，导入util命名空间

</util:list>

3.作用域，p赋值，自动装配，模板

<bean id=”person” class=”全类名”

scope=”singleton” //bean的作用域singleton默认单例，prototype原型

p:age=”50” p:name=”XX” //p赋值，导入p命名空间

p:cars-ref=”cars”(/autowire=”byName”) //autowire引用类属性的自动装配/byType

abstract=”true”> //abstract模板（class属性没有就一定是抽象bean）

</bean>

<bean id=”person2” p:age=”60” depends-on=”car” parent=”person”></bean> //继承bean，depends-on依赖必须有car

4.本地配置文件引用，SpEl

<context:property-placeholder location="classpath:db.properties"/> //引用本地配置文件，引用context命名空间

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="${user}"></property> //引用格式

driverClass=com.mysql.cj.jdbc.Driver //高版本MySql注意配置的改动

jdbcUrl=jdbc:mysql://localhost:3306/bookStore?useSSL=false&serverTimezone=UTC

5.生命周期

<bean id=”person” class=”全类名”

Init-method=”init” //bean的生命周期

Destory-method=”destory”

p:age=”50” p:name=”XX”>

</bean>

<bean class=”bean的后置处理器的全类名”></bean> //继承BeanPostProcessor接口，抛

BeanException异常，实现postProcessBeforeInitialization(object bean, String beanName)和 postProcessAfterInitialization

6.工厂方法

<bean id=”car”

class=”静态工厂全类名”

factory-method=”getCar”> //静态工厂方法

<constructor-org value=”audi”></constructor-org>

</bean>

<bean id=”carFactory” class=”工厂全类名”</bean> //实例工厂方法

<bean id=”car2”

class=”实例工厂全类名”

factory-method=”getCar”>

<constructor-org value=”ford”></constructor-org>

</bean>

//继承FactoryBean<T>，实现getObject,getObjectType,isSingletn方法

<bean id=”car” class=”bean工厂全类名”

</bean>

4.注解

<context:component-scan //配置

use-default-filter=”true” //默认true扫描全类，false不扫描

base-package=”全包名” //注解生效区域

resource-pattern=”repository/*.class”> //限制范围内只读repository的id

<context:exclude-filter type=”annotation” //生效区域中排除类/annotation根据注解

Expression=”不包含的类”/>

<context:include-filter type=”annotation” //生效区域中排除类/assignable根据具体类

Expression=”只包含的类”/>

</context:component-scan>

@Component@Respository

@Service@Controller(“value”) //类注解，自动配置bean,value修改bean的id

@Autowired(required=”false”) //字段or方法注解，自动装配bean，required无法装配则为null

@Qualifier(“beanName”) //限定bean的id

//泛型依赖注入，通过注解建立泛型之间的关系，子类会自动继承

5.AOP使用

1.代理使用

public class xxProxy {

private xx target; //要代理的对象

public xxProxy(xx target) {

super();

this.target = target;

}

public xx getxxProxy(){ //返回代理对象

xx proxy = null;

ClassLoader loader = target.getClass().getClassLoader(); //代理对象使用的类加载器

Class [] interfaces = new Class[]{xx.class}; //类方法

InvocationHandler h = new InvocationHandler() { //方法代理执行语句

//proxy: 代理对象。一般不使用该对象，method: 正在被调用的方法，args: 调用方法传入的参数

@Override

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

String methodName = method.getName();

//打印日志

System.out.println("[before] The method " + methodName + " begins with " + Arrays.asList(args));

//调用目标方法

Object result = null;

try {

//前置通知

result = method.invoke(target, args); //调InvocationHandler的invoke

//返回通知, 可以访问到方法的返回值

} catch (NullPointerException e) {

e.printStackTrace();

//异常通知, 可以访问到方法出现的异常

}

//后置通知. 因为方法可能会出异常, 所以访问不到方法的返回值

//打印日志

System.out.println("[after] The method ends with " + result);

return result;

}

};

proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);

return proxy;

}

2.基于注解使用AOP

<aop:aspectj-autoproxy></aop:aspectj-autoproxy> //加入使 AspjectJ 注解起作用的配置

@Order(2) //执行顺序

@Aspect //声明是一个切面

@Component

public class LoggingAspect {

//前置通知

@Before("execution(public int com.atguigu.spring.aop.ArithmeticCalculator.*(int, int))")

public void beforeMethod(JoinPoint joinPoint){ //joinPoint访问方法签名和方法参数

String methodName = joinPoint.getSignature().getName();

Object [] args = joinPoint.getArgs();

System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));

}

@After("execution(* com.atguigu.spring.aop.*.*(..))") //后置通知

//@AfterReturning返回通知，(returning=”result”)

//@AfterThrowing异常通知，(throwing=”ex”)

//@Around环绕通知综合上面4种通知

}

@Pointcut(“xx”) public void xx (){} //切点表达式

@After(value=”xx”) //切点调用

3.基于配置文件使用AOP

<aop:config>

<aop:pointcut expression="execution(* com.atguigu.spring.aop.xml.ArithmeticCalculator.*(int, int))" id="pointcut"/>

<aop:aspect ref="loggingAspect" order="2">

<aop:before method="beforeMethod" pointcut-ref="pointcut"/>

<aop:after method="afterMethod" pointcut-ref="pointcut"/>

<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/>

<aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>

<aop:around method="aroundMethod" pointcut-ref="pointcut"/>

</aop:config>

6.JdbcTemplete使用

<bean id="namedParameterJdbcTemplate"

class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">

<constructor-arg ref="dataSource"></constructor-arg></bean>

@Autowired

private JdbcTemplate jdbcTemplate;

public Employee get(Integer id){ //不支持级联属性映射

String sql = "SELECT id, last_name lastName, email FROM employees WHERE id = ?";

RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);

Employee employee = jdbcTemplate.queryForObject(sql, rowMapper, id);

return employee;

}

List<Object[]> batchArgs = new ArrayList<>();

jdbcTemplate.batchUpdate(sql, batchArgs);

SqlParameterSource paramSource = new BeanPropertySqlParameterSource(employee);

namedParameterJdbcTemplate.update(sql, paramSource);

Map<String, Object> paramMap = new HashMap<>();

namedParameterJdbcTemplate.update(sql, paramMap);

7.事务使用

1.基于注解使用事务

<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

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

//添加事务注解

//1.使用 propagation 事务传播行为,默认REQUIRED/REQUIRES_NEW

//2.使用 isolation 事务隔离级别, 最常用的取值为 READ_COMMITTED..

//3.使用noRollbackFor 默认所有运行时异常回滚.

//4.使用 readOnly 指定事务是否为只读. 默认false/true

//5.使用 timeout 指定强制回滚之前事务可以占用的时间.

@Transactional(propagation=Propagation.REQUIRES_NEW,readOnly=false,timeout=3,

isolation=Isolation.READ_COMMITTED,noRollbackFor={UserAccountException.class})

2.基于配置使用事务

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="purchase" propagation="REQUIRES_NEW"/>

<tx:method name="get*" read-only="true"/>

<tx:method name="find*" read-only="true"/>

<tx:method name="*"/>

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut expression="execution(* com.atguigu.spring.tx.xml.service.*.*(..))"

id="txPointCut"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>

</aop:config>

7.整合Hibernate

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
  <session-factory>
    <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
    <property name="hibernate.show_sql">true</property>
    <property name="hibernate.format_sql">true</property>
    <property name="hibernate.hbm2ddl.auto">update</property>  //生成表的策略
  </session-factory>
</hibernate-configuration>

<?xml version='1.0'?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
      "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>

   <class name="me2.untitled.Entity.Account" table="SH_ACCOUNT">
      <id name="id" type="java.lang.Integer">
         <column name="Id"/>
         <generator class="assigned"/>
      </id>
   </class>
</hibernate-mapping>


    
    
    

<bean id="SessionFactory" class=

"org.springframework.orm.hibernate5.LocalSessionFactoryBean">
     <property name="dataSource" ref="dataSource"></property>
     <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
     <property name="mappingLocations" value="classpath:me2/untitled/Entity/*.hbm.xml"></property></bean>

    
    <bean id="transactionManager" class=

"org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="SessionFactory"></property>
    </bean>

    

@Autowired

private SessionFactory sessionFactory;

//获取和当前线程绑定的 Session.

private Session getSession(){

return sessionFactory.getCurrentSession();

}

@Override

public int findBookPriceByIsbn(String isbn) {

String hql = "SELECT b.price FROM Book b WHERE b.isbn = ?";

Query query = getSession().createQuery(hql).setString(0, isbn);

return (Integer)query.uniqueResult();

}

//String hql2 = "SELECT b.stock FROM Book b WHERE b.isbn = ?";

//int stock = (int) getSession().createQuery(hql2).setString(0, isbn).uniqueResult();

//String hql = "UPDATE Book b SET b.stock = b.stock - 1 WHERE b.isbn = ?";

//getSession().createQuery(hql).setString(0, isbn).executeUpdate();

8.Web中使用spring

1.基本实现

//listeners监听

public class SpringServletContextListener implements ServletContextListener {

public SpringServletContextListener() {}

public void contextDestroyed(ServletContextEvent arg0) {}

public void contextInitialized(ServletContextEvent arg0) {

//1. 获取 Spring 配置文件的名称

ServletContext servletContext = arg0.getServletContext();

String config = servletContext.getInitParameter("configLocation");

//2. 创建 IOC 容器

ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

//3. 把 IOC 容器放在 ServletContext 的一个属性中

servletContext.setAttribute("ApplicationContext", ctx);

}

//servlets小服务

public class TestServlet extends HttpServlet {

private static final long serialVersionUID = 1L;

protected void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

//1. 从 application 域对象中得到 IOC 容器的引用

ServletContext servletContext = getServletContext();

ApplicationContext ctx = (ApplicationContext) servletContext.getAttribute("ApplicationContext");

//2. 从 IOC 容器中得到需要的 bean

Person person = ctx.getBean(Person.class);

person.hello();

}

//配置文件中创建servielt bean

//jsp页面

2.接口实现

//Web.xml

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:applicationContext.xml</param-value>

</context-param>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

9.整合strut2

//导入struts2包

//在web.xml中加入struts2的web的Filter配置

<filter-name>struts2</filter-name>

<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>

</filter>

<filter-mapping>

<ilter-name>struts2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

//加入struts2.xml

//配置文件配置Action的bean

//struts2.xml中配置页面调用bean来创建Action

<result>/success.jsp</result>

</action>

//加入 struts2-spring-plugin-2.3.15.3.jar，Struts2 会先从 IOC 容器中获取 Action 的实例