spring 开发参考文档

最新推荐文章于 2023-09-20 21:42:53 发布
最新推荐文章于 2023-09-20 21:42:53 发布
阅读量1.2k 收藏 5
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25272679/article/details/96472891
版权

目录

介绍

  • 在此只介绍如何使用spring IOC、AOP、JDBC等功能。
  • 这个仅是开发参考文档，方便快速查阅使用。

spring架构图

在这里插入图片描述

spring配置方式

  • 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"
    xmlns:c="http://www.springframework.org/schema/c"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- service -->
    <bean id="service" class="iocAndDIAndWiring.Service"></bean>
</beans>
  • java config类
@Configuration //配置文件
//组件扫描：扫描此类所在的包。
//xml配置文件中:<context:annotation-config/>
@ComponentScan 
public class JavaConfig {
    @Bean //bean装配
    public Service service() {
        return new Service();
    }
}

spring装配Bean(此处只介绍xml配置)

xml配置比较复杂，所以在这里详细介绍

构造器装配Bean

<?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:c="http://www.springframework.org/schema/c"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- service -->
    <bean id="service" class="iocAndDIAndWiring.Service"></bean>
    
    <!-- 使用构造器装配 -->
    <bean id="handler" class="iocAndDIAndWiring.Handler">
        <constructor-arg ref="service"></constructor-arg>
    </bean>
    
    <!-- c标签创建handler Bean -->
    <bean id="handler" class="iocAndDIAndWiring.Handler" c:service-ref="service"></bean>
</beans>

set装配Bean

<!-- handler -->
<bean id="handler" class="iocAndDIAndWiring.Handler">
    <property name="title" value="hello"></property>
    <property name="art" value="java"></property>
    <property name="hobby">
        <list>
            <value>hello</value>
            <value>world</value>
        </list>
    </property>
</bean>

<!-- p标签  p:参数名-ref装配对象、p:参数名 装配字面量-->
<bean id="handler" class="iocAndDIAndWiring.Handler" p:title="hello" p:art="art">
    <property name="hobby">
        <list>
            <value>hello</value>
            <value>world</value>
        </list>
    </property>
</bean>

运行时值注入

  • 属性占位符：${""}
  1. Environment实现
@Configuration
@PropertySource("iocAndDIAndWiring/prop.properties")
public class SpringConfig {
    @Autowired
    Environment env;
    @Bean
    public Service service() {
        return new Service(env.getProperty("title"), env.getProperty("name"));
    }
}
  1. @Value实现
@Configuration
@PropertySource("iocAndDIAndWiring/prop.properties")
public class SpringConfig {
    @Bean
    public static PropertySourcesPlaceholderConfigurer placeholderConfigurer() {
        return new PropertySourcesPlaceholderConfigurer();
    }
    @Bean
    public Service service(@Value("${title}") String title,@Value("${name}") String name) {
        return new Service(title, name);
    }
}
  1. xml配置
<context:property-placeholder location="iocAndDIAndWiring/prop.properties"/>

<bean id="service" class="iocAndDIAndWiring.Service" c:title="${title}" c:name="${name}"></bean>
  • 使用spEL
    等以后补充。

list、set、map、prop配置

<!--  list、set、map、prop属性赋值 -->
 <list>
    <value>world</value>
    <value>hello</value>
</list>

<set>
    <value>hello</value>
    <value>world</value>
</set>
    
<!-- 对于引入bean -->
<set>
    <ref bean="bean1" />
    <ref bean="bean2" />
    //父xml配置
    <ref parent="parentBean1">
</set>
	
<property name="hobby">
	 <props>
	     <prop key="key">value</prop>
	 </props>
	 
	 <map>
	     <entry key="key" value="value"></entry>
	 </map>
</property>

<!--  util配置集合属性 -->
<bean id="handler" class="iocAndDIAndWiring.Handler" p:title="hello" p:art="art">
    <property name="hobby">
        <util:list>
            <value>hello</value>
            <value>world</value>
        </util:list>
    </property>
</bean>

懒加载

  • ioc容器初始化的时候，不创建懒加载的类，等需要时才会创建。
<bean id="lazy" class="com.something.ExpensiveToCreateBean" lazy-init="true"/>

//ioc容器全部懒加载
<beans default-lazy-init="true">

混合配置

  • java类混合xml
    @ImportResource，导入xml文件即可。
@Configuration
@ImportResource("iocAndDIAndWiring/spring.xml")
public class SpringConfig {
    @Bean
    public Service service() {
        return new Service();
    }
}
  • xml混合java类
    引入配置类即可
<!-- springCOnfig 配置类 -->
<bean class="iocAndDIAndWiring.SpringConfig" />

自动装配

  • 实现方式
@AutoWired
public void setIce(Ice ice) {
}
  • 歧义问题
  1. 标记首选的bean
@component
@Primary
public class Ice{}
  1. @Qualifier - 限定自动装配的bean
@AutoWired
@Qualifier("beanId") //@Qualifier,根据bean id限定使用哪个bean
public void setIce(Ice ice) {
}
  1. 创建自定义的限定符注解
@Target(ElementType.CONSTRUCTOR,ElementType.FIELD,ElementType.METHOD,ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Ice{}

@AutoWired
@Ice
public void setIce(Ice ice) {
}

bean的作用域

  • 单例（singeton）
  • 原型（prototype）
  • 会话（session）: web应用使用
  • 请求（request）：web应用使用
@Component
//@Scope("prototype") 不安全
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class Ice{}
  1. 购物车
@Component
@Scope(
    value=WebApplicationContext.SCOPE_SESSION,
    //接口代理模式，另一种是类代理模式
    proxyMode=ScopedProxyMode.INTERFACES
)
public class ShopCart{}

//xml配置
<bean id="shopCart" class="ShopCart" scope="session">
    //默认使用CGLib类代理
    <aop:scoped-proxy />
    //<aop:scoped-proxy proxy-target-class="false"/>
</bean>

AOP面向切面编程

  • 注解实现
  1. @Before、@After、@AfterReturning、@AfterThrowing
@Configuration
@ComponentScan
@EnableAspectJAutoProxy
public class JavaConfig {
    //环绕通知
    @Bean
    public aop.环绕通知.Audience audience() {
        return new aop.环绕通知.Audience();
    }
    //before、afterReturn、afterThrow
    @Bean
    public Audience audience1() {
        return new Audience();
    }
    //引入新功能
    @Bean
    public AddMethod addMethod() {
        return new AddMethod();
    }
    @Bean
    public Performance performance() {
        return new PerformanceImpl();
    }
}
  1. @Around
@Aspect
public class Audience {
    /**
     * 定义切点
     */
    @Pointcut("execution(** aop.Performance.perform(..))")
    public void performamce(){}
    @Around("performamce()")
    public void watchPerformance(ProceedingJoinPoint jp) {
        try {
            System.out.println("手机静音2。。。");
            System.out.println("观众坐下2。。。");
            //连接点，即拦截的方法调用
            jp.proceed();
            System.out.println("观众喝彩2。。。");
        } catch (Throwable e) {
            System.out.println("观众退票2。。。");
            e.printStackTrace();
        }
    }
}
  • xml配置
<!-- aop -->
<aop:config>
    <aop:aspect ref="aop">
        <aop:pointcut expression="execution(** aop.xml.Service.*(..))" id="p"/>
        <aop:before method="before" pointcut-ref="p"/>
        <aop:after method="after" pointcut-ref="p"/>
        <aop:around method="around" pointcut-ref="p"/>
    </aop:aspect>
</aop:config>

spring Data

  • JDBC
  1. xml配置
<bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/yiibaijava" />
        <property name="username" value="root" />
        <property name="password" value="password" />
</bean>
  1. java类配置
@Bean
public DataSource dataSource() {
    DriverManagerDataSource ds = new DriverManagerDataSource();
    ds.setDriverName("org.h2.Driver");
    ds.setUrl("jdbc:h2:tcp://localhost/~/spitter");
    ds.setUserName("");
    ds.setPassWord("");
    return ds;
}
  1. 使用
public class JdbcCustomerDAO implements CustomerDAO
{
    private DataSource dataSource;
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    public void insert(Customer customer){
        String sql = "INSERT INTO CUSTOMER " +
                "(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
            PreparedStatement ps = conn.prepareStatement(sql);
            ps.setInt(1, customer.getCustId());
            ps.setString(2, customer.getName());
            ps.setInt(3, customer.getAge());
            ps.executeUpdate();
            ps.close();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {}
            }
        }
    }
    public Customer findByCustomerId(int custId){
        String sql = "SELECT * FROM CUSTOMER WHERE CUST_ID = ?";
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
            PreparedStatement ps = conn.prepareStatement(sql);
            ps.setInt(1, custId);
            Customer customer = null;
            ResultSet rs = ps.executeQuery();
            if (rs.next()) {
                customer = new Customer(
                    rs.getInt("CUST_ID"),
                    rs.getString("NAME"), 
                    rs.getInt("Age")
                );
            }
            rs.close();
            ps.close();
            return customer;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            if (conn != null) {
                try {
                conn.close();
                } catch (SQLException e) {}
            }
        }
    }
}
  • JdbcTemplate
  1. xml配置
 <!-- 配置C3P0数据源 -->
    <bean id="dataSource"
        class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>

        <property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
    </bean>

    <!-- 配置Spring的jdbcTemplate 
        并注入一个dataSource数据源-->
    <bean id="jdbcTemplate"
        class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>    
    </bean>
  1. 使用
  • 添加
String sql="insert into user (name,deptid) values (?,?)";
jdbcTemplate.update(sql, new Object[]{"caoyc",3});
  • 修改
String sql="update user set name=?,deptid=? where id=?";
jdbcTemplate.update(sql,new Object[]{"zhh",5,51});
  • 删除
String sql="delete from user where id=?";
jdbcTemplate.update(sql,51);
  • batchUpdate()批量插入、更新和删除方法
String sql="insert into user (name,deptid) values (?,?)";
List<Object[]> batchArgs=new ArrayList<Object[]>();
batchArgs.add(new Object[]{"caoyc",6});
batchArgs.add(new Object[]{"zhh",8});
batchArgs.add(new Object[]{"cjx",8});
jdbcTemplate.batchUpdate(sql, batchArgs);
  • 读取单个对象
String sql="select id,name,deptid from user where id=?";
RowMapper<User> rowMapper=new BeanPropertyRowMapper<User>(User.class);
User user= jdbcTemplate.queryForObject(sql, rowMapper,52);
System.out.println(user);
  • 读取多个对象
String sql="select id,name,deptid from user";
RowMapper<User> rowMapper=new BeanPropertyRowMapper<User>(User.class);
List<User> users= jdbcTemplate.query(sql, rowMapper);
for (User user : users) {
    System.out.println(user);
}
  • 获取某个记录某列或者count、avg、sum等函数返回唯一值
String sql="select count(*) from user";
int count= jdbcTemplate.queryForObject(sql, Integer.class);
System.out.println(count);
  • NamedParameterJdbcTemplate
    NamedParameterJdbcTemplate和JdbcTemplate功能基本差不多。使用方法也类型。下面具体看下代码。
  1. 方式1
//为变量名称前面加上冒号
String sql="insert into user (name,deptid) values (:name,:deptid)";
//定义map集合，其参数名称为sql语句中变量的名称
Map<String,Object> paramMap=new HashMap<String,Object>();
paramMap.put("name", "caoyc");
paramMap.put("deptid", 2);
namedParameterJdbcTemplate.update(sql, paramMap);
  1. 方式2
//为变量名称前面加上冒号
String sql="insert into user (name,deptid) values (:name,:deptid)";
//定义个实体类
User user=new User();
user.setName("zhh");
user.setDeptid(3);
SqlParameterSource paramSource=new BeanPropertySqlParameterSource(user);
namedParameterJdbcTemplate.update(sql, paramSource);
  • hibernate使用
  1. 通过注入sessionFactory，通过setSessionFactory()方法实现
    编写dao继承HibernateDaoSupport， 注入sessionFactory创建。
@Repository
public class SysUserDaoImpl extends HibernateDaoSupport implements SysUserDao {
    @Autowired
    public void setSessionFactor(SessionFactory sessionFactory) {
        super.setSessionFactory(sessionFactory);
    }

    @Override
    public SysUser findSysUserById(String id) {
        return this.getHibernateTemplate().get(SysUser.class, id);
    }

}

//xml配置
<!-- 数据源 ，使用c3p0 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driver}" />
    <property name="jdbcUrl" value="${jdbc.url}" />
    <property name="user" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
    <!-- 最大连接数，建议在开发环境中设置小一点，够用即可 -->
    <property name="maxPoolSize" value="3" />
    <!-- 最小连接数 -->
    <property name="minPoolSize" value="1" />
</bean>


<!-- sessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <!-- 数据库源 -->
    <property name="dataSource" ref="dataSource" />
    
    <!-- 设置hibernate属性 -->
    <property name="hibernateProperties">
        <props>
            <!-- 方言 -->
            <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
            <!-- 日志输出显示sql -->
            <prop key="hibernate.show_sql">true</prop>
            <!-- 日志输出中格式化sql -->
            <prop key="hibernate.format_sql">true</prop>
            <!-- 从hbm文件到数据库定义策略，建议设置为none，不检查po类和表结构是否一致 -->
            <prop key="hibernate.hbm2ddl.auto">none</prop>
            <!-- 配置Hibernate的session管理机制，spring与hibernate整合后采用当session与当前线程绑定 -->
            <prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate5.SpringSessionContext</prop>
        </props>
    </property>
    <!-- 加载映射文件 -->
    <property name="mappingLocations">
        <list>
            <value>classpath:com/xxx/xxx/*.hbm.xml</value>
        </list>
    </property>
</bean>
  1. 通过注入hibernateTemplate实现，通过setHibernateTemplate()方法实现
@Repository
public class SysUserDaoImpl extends HibernateDaoSupport implements SysUserDao {
    @Autowired
    public void setHT(HibernateTemplate hibernateTeplate) {
        super.setHibernateTemplate(hibernateTeplate);
    }

    @Override
    public SysUser findSysUserById(String id) {
        return this.getHibernateTemplate().get(SysUser.class, id);
    }
}

//xml配置
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
	<!-- spring与hibernate整合后默认必须在事务下对数据库执行写操作，如果将checkWriteOperations设置为false则没有事务也可写数据库，这样是为了单独测试dao方便 -->
	 <property name="checkWriteOperations" value="false"/>
	 <property name="sessionFactory" ref="sessionFactory"/>
</bean>
  • 事务管理
  1. 事务的隔离级别
    在这里插入图片描述
  2. 事务的传播行为
    在这里插入图片描述
  3. 编程事务
  • demo demo
  • 第二种TransactionTemplate实现
@Resource   
private  TransactionTemplate transaction;

private void f(){    
	transaction.execute(new TransactionCallback<Void>() {        
	@Override           
	publicVoid doInTransaction(TransactionStatus status) {              
	 // update1                
	 // update2               
	 returnnull;
	 }        });
}

//xml配置
<!-- Initialization for data source -->
   <bean id="dataSource" 
      class="org.springframework.jdbc.datasource.DriverManagerDataSource">
      <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
      <property name="url" value="jdbc:mysql://localhost:3306/TEST"/>
      <property name="username" value="root"/>
      <property name="password" value="password"/>
   </bean>

   <!-- Initialization for TransactionManager -->
   <bean id="transactionManager" 
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource"  ref="dataSource" />    
   </bean>

<!-- Definition for studentJDBCTemplate bean -->
<bean id="transactionTemplate"
   class="org.springframework.transaction.support.TransactionTemplate">
   <property name="dataSource"  ref="dataSource" />
   <property name="transactionManager"  ref="transactionManager" />    
</bean>
  1. 声明式事务
  • 基于 TransactionProxyFactoryBean的声明式事务管理
    <bean id="buyStockService" class="transaction.test2.service.BuyStockServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
        <property name="stockDao" ref="stockDao"></property>
    </bean>
  
    <!-- 事务管理器 -->
<bean id="myTracnsactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>
    
    <!-- 事务代理工厂 -->
<!-- 生成事务代理对象 -->
<bean id="serviceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="transactionManager" ref="myTracnsactionManager"></property>
        <property name="target" ref="buyStockService"></property>
        <property name="transactionAttributes">
            <props>
                <!-- 主要 key 是方法   
                    ISOLATION_DEFAULT  事务的隔离级别
                    PROPAGATION_REQUIRED  传播行为
                -->
                <prop key="add*">ISOLATION_DEFAULT,PROPAGATION_REQUIRED</prop>
                <!-- -Exception 表示发生指定异常回滚，+Exception 表示发生指定异常提交 -->
                <prop key="buyStock">ISOLATION_DEFAULT,PROPAGATION_REQUIRED,-BuyStockException</prop>
            </props>
        </property>
</bean>
  • 基于 @Transactional 的声明式事务管理
<!-- 事务管理器 -->
<bean id="myTracnsactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>
    
<!-- 启用事务注解 -->
 <tx:annotation-driven transaction-manager="myTracnsactionManager"/>
  • 基于Aspectj AOP配置事务
<!-- 事务管理器 -->
<bean id="myTracnsactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>
    
 <tx:advice id="txAdvice" transaction-manager="myTracnsactionManager">
     <tx:attributes>
         <!-- 为连接点指定事务属性 -->
         <tx:method name="add*" isolation="DEFAULT" propagation="REQUIRED"/>
         <tx:method name="buyStock" isolation="DEFAULT" propagation="REQUIRED" rollback-for="BuyStockException"/>
     </tx:attributes>
 </tx:advice>
    
 <aop:config>
     <!-- 切入点配置 -->
     <aop:pointcut expression="execution(* *..service.*.*(..))" id="point"/>
     <aop:advisor advice-ref="txAdvice" pointcut-ref="point"/>
 </aop:config>

spring mvc

控制器controller

配置DispatcherServlet到servlet容器内，而不再配置到web.xml中

  • 配置DispatcherServlet
public class SpittrWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    //配置根配置类
    @Override
    protected Class<?>[] getRootConfigClasses() {
        //return new Class[]{RootConfid.class};
        return new Class[0];
    }

    //指定servlet配置类
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    //将DispatcherServlet映射到 '/' 目录。
    @Override
    protected String[] getServletMappings() {
        return new String[] {"/"};
    }
}
  • 控制器demo
@Controller
@RequestMapping("/spittles") //类级别的请求处理
public class SpittrController {
    @RequestMapping(value = "/test", method= RequestMethod.GET)
    //传递model模型数据到视图中。
    public String test(Model model) {
        model.addAttribute("test", "hello");
        return "test";
    }
}
  • 接受请求参数方式
  1. 查询参数（query parameter）
    @RequestParam
@RequestMapping("/test01")
public void test01(
	@RequestParam(value="max", defaultValue="20") long max,
	@RequestParam("count") long count) { 
}
  1. 路径参数（path parameter）
@RequestMapping("/test02/{id}")
public void test02(@PathVariable("id") long id) {
}
  1. 表单参数（form parameter）
// obj代表任意java对象，表单参数可封装到java对象中去。
@RequestMapping(value = "/test03/save", method = RequestMethod.POST)
public String test03(Object obj) {
	return "redirect:/spitter/name";
	//return "forward:/spitter/name";
}
  1. 校验表单
    这些注解可以放到属性上，限制这些属性的值。
    在这里插入图片描述
    在这里插入图片描述
  • 配置demo
public class Spitter {
    @NonNull
    @Size(min=0, max=16)
    private String username;
}

//controller
@RequestMapping(value = "/test04", method = RequestMethod.POST)
public void test04(@Validated Spitter obj) {
}

渲染Web视图

  • ViewResolver视图解析器
public interface ViewResolver {
    View resolveViewName(String var1, Locale var2) throws Exception;
}
  • View
public interface View {
    String RESPONSE_STATUS_ATTRIBUTE = View.class.getName() + ".responseStatus";
    String PATH_VARIABLES = View.class.getName() + ".pathVariables";
    String SELECTED_CONTENT_TYPE = View.class.getName() + ".selectedContentType";

    String getContentType();

    void render(Map<String, ?> var1, HttpServletRequest var2, HttpServletResponse var3) throws Exception;
}
  • 创建jsp视图
  1. demo
public ViewResolver viewResolver() {
	InternalResourceViewResolver internalResourceViewResolver = new InternalResourceViewResolver();
	//前缀
	internalResourceViewResolver.setPrefix("/WEB-INF/views/");
	//后缀
	internalResourceViewResolver.setSuffix(".jsp");
	//解析成jstlView
	internalResourceViewResolver.setViewClass(JstlView.class);
		
	return internalResourceViewResolver;
}
  1. spring下的jsp标签库
  • 表单
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    注意：
  1. <sf:errors path=“firstname”>标签的使用，可以验证表单数据输入有误后，展示的错误信息。
  2. 这里不再详细介绍jsp了，使用较少了。
  • 使用apache Tiles视图定义布局
  1. tilesConfigurer + tilesViewResolver 实现页面布局
@Bean
public TilesConfigurer tilesConfigurer() {
  TilesConfigurer tilesConfigurer = new TilesConfigurer();
  tilesConfigurer.setDefinitions(new String[] {
          "/WEB-INF/**/tiles.xml"
  });
  tilesConfigurer.setCheckRefresh(true); //启用刷新

  return tilesConfigurer;
}

@Bean
public TilesViewResolver tilesViewResolver() {
  return new TilesViewResolver();
}
  1. 定义tiles及使用
    在这里插入图片描述
    在这里插入图片描述
  • 使用Thymeleaf
    在这里插入图片描述
  1. demo，此处仅列举一个demo供参考
    在这里插入图片描述

spring mvc 高级用法

  • 添加其他的servlet和filter
    在这里插入图片描述
    在这里插入图片描述
  • spring mvc 在 web.xml的配置
    在这里插入图片描述
  • 处理multipart格式的数据
  1. 基于servlet3以上的实现
@Bean
public MultipartResolver multipartResolver() {
    return new StandardServletMultipartResolver();
}
  1. 配置上传文件
  • 使用servlet初始化类
public class MyInitConfig implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        DispatcherServlet dispatcherServlet = new DispatcherServlet();

        ServletRegistration.Dynamic appServlet = servletContext.addServlet("appServlet", dispatcherServlet);

        appServlet.setLoadOnStartup(1);
        appServlet.setMultipartConfig(new MultipartConfigElement("/tmp/uploads"));
    }
}
  • 不适用servlet初始化类,重载customizeRegistration()方法
@Override
protected void customizeRegistration(ServletRegistration.Dynamic registration) {
    super.customizeRegistration(registration);
    registration.setMultipartConfig(new MultipartConfigElement("/tmp/uploads"));
}
  • 使用传统web.xml配置
    在这里插入图片描述
  1. 使用FileUpload 处理文件上传
    在这里插入图片描述
  2. 处理文件上传请求
  • @RequestPart
@RequestMapping("/file01")
public void file01(@RequestPart("file") byte[] file) {
 }
  • MultipartFile
@RequestMapping("/file02")
public void file02(MultipartFile file) {
}
  • part形式处理
@RequestMapping("/file03")
public void file03(@RequestPart("file") Part file) {
}

处理异常

  • 将异常映射到Http状态码。以下为自定义异常
@ResponseStatus(value= HttpStatus.NOT_FOUND,
        reason = "Not Found")
public class MyException extends RuntimeException{
}
  • 编写异常处理方法
@ExceptionHandler(MyException.class)
public String handleException() {
     return "error";
 }

注意：异常情况是MyException时，会调用此方法。

  • 为控制器添加通知
    在这里插入图片描述

保护web应用

后续补充。。。

QA

  • 事务的传播行为
  1. 上图前三个，保证业务在同一个事务管理下。
  2. 中间三个，保证业务不再同一个事务管理
  3. 最后一个，第一个事务执行完后，会创建savepoint保存点，如果第二个事务出现异常，可以选择回滚到保存点，也可以回滚到最初的状态。

关联文章

@kyros
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot 集成接口文档，老鸟们也被打脸了！
m0_72758098的博客
04-17 602
在前后端分离项目中我们一般需要在请求接口时设置一个请求头，如token，Authorization等…后端根据请求头判断是否为系统合法用户，目前smart-doc也对其提供了支持。在smart-doc配置文件中继续追加如下配置内容：“requestHeaders”: [ //设置请求头，没有需求可以不设置“name”: “token”,//请求头名称“type”: “string”,//请求头类型“desc”: “自定义请求头 - token”,//请求头描述信息。
spring3.2参考文档
09-27
8. **参考文档**：`spring-framework-reference`是Spring 3.2的官方参考文档，详细介绍了如何使用框架的各个方面，包括配置、编程模型、特定模块的使用等。这份文档是开发者解决问题和学习新功能的关键资源。 9. **...
Spring中文文档
雁迟的博客
03-31 5753
中文文档：https://www.docs4dev.com/docs/zh/spring-framework/5.1.3.RELEASE/reference
Spring学习文档
qq_57457405的博客
10-19 924
Spring与SpringMVC基础知识点总结
Spring文档
mitujx的博客
07-13 1919
Spring文档部分机翻
Spring文档教程
qq_72239654的博客
06-25 235
Spring文档教程，Spring文档
spring开发文档
落地
12-15 691
一、什么是mybatis     MyBatis是支持普通SQL查询，存储过程和高级映射的优秀持久层框架。 MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis使用简单的XML或注解用于配置和原始映射，将接口和Java的POJOs（Plan Old Java Objects，普通的Java对象）映射成数据库中的记录。  二、mybatis包含新特性
Spring Framework开发中文参考文档
08-13
这个"Spring Framework中文开发参考文档"将详细阐述以上所有概念，并提供具体的使用方法、示例代码和配置指南，是学习和理解Spring Framework的宝贵资源。开发者可以通过阅读这份文档，深入学习Spring的各种特性和...
Spring.Net中文参考文档
03-11
综上所述，"Spring.Net中文参考文档"是一份非常有价值的资料，它涵盖了Spring.NET框架的主要特性和用法，对于想要学习和使用Spring.NET进行.NET开发的程序员来说，是不可或缺的学习资源。通过阅读和实践这份文档，...
spring开发文档集合
05-28
Spring开发文档集合是一个宝贵的资源，包含了关于Spring框架的多种学习材料。这个压缩包中的文档旨在帮助开发者深入理解和熟练使用Spring框架，它是一个广泛应用于Java企业级应用的开源框架。Spring以其依赖注入...
Spring数据JPA - 中文参考文档
09-05
在 Spring 中，JPA 与 Spring Data 结合，进一步简化了数据访问层的开发。 4. 使用 Spring 数据存储库 Spring Data 存储库抽象的主要目标是减少与持久化相关的样板代码。`Repository` 接口是整个抽象的核心，它是...
Spring框架参考文档（中文版PDF）
11-09
Spring框架参考文档（中文版PDF）Spring框架参考文档（中文版PDF）
Spring5.0参考文档中文版
09-18
Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。
spring框架api中文版.zip(spring开发手册）
04-06
有两种格式，一种和jdk的api一样，另一种是PDF格式，pdf部分目录如下： 即Spring框架的概述 1。 介绍Spring框架 1.1。 依赖注入和控制反转 1.2。 模块 1.2.1。 核心容器 1.2.2。 数据访问/集成 1.2.3。 web 1.2.4。 AOP和仪表 1 2 5。 测试 1.3。 使用场景 1.3.1。 依赖关系管理和命名约定 Spring依赖和依靠弹簧 Maven依赖管理 艾薇依赖管理 1.3.2。 日志 不使用通用日志 使用SLF4J 使用Log4j 二世。 什么是新的在春季3 2。 新特性和增强功能在Spring框架3.0 2.1。 Java 5 2.2。 改进文档 2.3。 新的文章和教程 2.4。 新模块的组织和构建系统 2.5。 概述的新特性 2 5 1。 核心api更新Java 5 2 5 2。 弹簧表达式语言 2 5 3。 这个控制反转(IoC)容器 基于Java bean的元数据 元数据定义bean组件内
Spring中文API帮助文档
06-05
spring中文API文档 spring中文API文档 spring中文API文档 spring中文API文档
Spring5.0中文开发手册
10-10
Spring5.0中文开发手册，内容很全，条理清晰~~~~~放心下载，
Spring Framework文档-概述（Overview）
dzq584462393的专栏
07-21 452
Spring Framework概述
SpringBoot（实用开发篇）
暮辰的博客
06-30 676
SpringBoot实用开发篇 第三方属性bean绑定 @ConfigurationProperties 使用@ConfigurationProperties为第三方bean绑定属性 配置文件 datasource: driverClassName: com.mysql.jdbc.Driver servers: ipAddress: 192.168.0.1 port: 80 timeout: -1 ServerConfig类： @Data //@Component @Configurati
spring framework spring-boot spring-cloud 官方文档入口
最新发布
程序猿-Jojo
09-20 216
spring-boot 2.7 https://docs.spring.io/spring-boot/docs/2.7.15/reference/html/spring framework 5.2.release https://docs.spring.io/spring-framework/docs/5.2.25.RELEASE/spring-framework-reference/spring-cloud 2021 https://docs.spring.io/spring-cloud/docs/202

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值