spring框架知识总结

最新推荐文章于 2022-09-06 17:04:08 发布
最新推荐文章于 2022-09-06 17:04:08 发布
阅读量137 收藏
点赞数
文章标签： java 数据库 web.xml
原文链接：http://www.cnblogs.com/dw504723130/p/10806330.html
版权
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连接标准

 

//在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>  //引用类型传值

<property name=”car”>

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

</property>

<property name=”car”>

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

<property name=”子bean属性” value=”值”>

</bean>

</property>

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

<property name=”cars”>

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

<ref bean=”id”/>

</list>

<map>  //map

<entry key=”aa” value-ref=”car”/>

</map>

</property>

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

<props>

<prop key=”user” value=”root”></prop>

</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命名空间

<ref bean=”car1”>

<ref bean=”car2”>

</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>  //引用格式

<property name="pi" value="#{(java.lang.Math).PI*80}"></property>//Spel:常量,方法,if:
</bean>

 

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工厂全类名”

<property name=”brand” value=”BMW”></property>

</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

<!-- 配置 bean -->

<bean id="xx" class="com.atguigu.spring.aop.xml.xx"></bean>

<!-- 配置切面的 bean -->

<bean id="loggingAspect" class="LoggingAspect全类名"></bean>

<bean id="vlidationAspect" class="VlidationAspect全类名"></bean>

 

<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使用

<!-- 配置 Spirng 的 JdbcTemplate -->

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

<property name="dataSource" ref="dataSource"></property></bean>

 

 

<!-- 配置 NamedParameterJdbcTemplate, 没有无参数的构造器 -->

<bean id="namedParameterJdbcTemplate"

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

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

 

<!-- 使用JdbcTemplate -->

@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);

 

<!-- 使用NamedParameterJdbcTemplate -->

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">

<property name="dataSource" ref="dataSource"></property></bean>

<!-- 启用事务注解 -->

<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.基于配置使用事务

<!-- 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>

 

<!-- 3. 配置事务切入点, 以及把事务切入点和事务属性关联起来 -->

<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>


    <!--引用外部配置文件-->
    <!-- 配置本地包注解 -->
    <!-- 配置 DataSource -->
    <!-- 配置 Hibernate 的 SessionFactory -->

<!-- 配置 AspjectJ 注解 -->

<!-- 配置 SessionFactory -->

<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>
<!-- 配置事务属性txAdvice -->
    <!-- 3. 配置事务切入点, 以及把事务切入点和事务属性关联起来 -->

 

@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

<!-- 配置 Spring 配置文件的名称和位置 -->

<context-param>

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

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

</context-param>

 

<!-- 启动 IOC 容器的 ServletContextListener -->

<listener>

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

</listener>

 

 

9.整合strut2

//导入struts2包

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

<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

<action name="person-save" class="personAction">

<result>/success.jsp</result>

</action>

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

转载于:https://www.cnblogs.com/dw504723130/p/10806330.html

weixin_34376986
关注
Spring框架知识点
rjc260225728的博客
11-02 338
1. Spring概述 1.1 什么是框架？ 框架（Framework）：框（指其约束性）架（指其支撑性），在软件设计中指为解决一个开放性问题而 设计的具有一定约束性的支撑结构。在此结构上可以根据具体问题扩展、安插更多的组成部分，从而更 迅速和方便地构建完整的解决问题的方案。 1、框架本身一般不完整到可以解决特定问题 2、框架天生就是为扩展而设计的 3、框架里面可以为后续扩展的组件提供很多辅助性、支撑性的方便易用的实用工具（utilities）， 也就是说框架时常配套了一些帮助解决某类问题的
Spring框架学习总结
thinkhi9999的博客
08-16 1209
Spring框架的优势是模块化的IoC设计模式，使得开发人员可以专心开发程序的模块化部分。它能够降低开发企业级应用的复杂性，使用Spring替代EJP发开企业级应用，而不用提心工作量太大，开发进度难以控制和复杂的测试过程等问题。Spring简化了企业级应用的开发，降低了开发成本并整合了各种流行框架，它以IoC和AOP(面向切面编程)两种先进的技术为基础，完美简化了企业级应用开发的复杂度。 Spring组成 ...
Spring框架知识点总结
冰颜小神的博客
12-27 859
Spring的两大特征，IOC：依赖注入控制反转；AOP：面向切面编程； 1.AOP的几个关键词： 切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。 在Spring AOP中，切面可以使用通用类（基于模式的风格） 或者在普通类中以 @Aspect 注解（@AspectJ风格）来实现。 连接点（Joinpoin
Spring框架知识要点总结（第一天）
weixin_30670151的博客
11-22 128
1.IOC容器创建的2种方式 //首先在applicationContext.xml配置文件中写 <bean id="user" name="1ds@@user" class="c_ioc_bean.user"/> //创建方式一： //Spring把所有的配置文件都当做资源 ClassPathResource resource = new C...
Spring Framework
程序员的博客
09-05 1078
介绍: Spring Framework核心支持依赖注入，事务管理，Web应用程序，数据访问，消息传递，测试和更多功能。 Spring 官网：https://spring.io/ Spring 文档：https://spring.io/guides Spring Project:https://spring.io/projects 项目快速生成器：https://start.spring.io/ Spring框架为现代基于Java的企业应用程序提供了一个全面的编程和配置模型 - 在任何类...
Spring框架知识总结（浅显易懂）
shassd的博客
06-16 244
Spring的总结 Spring 是一款优秀的开源框架 ，他解决的是业务逻辑层和其他各层的耦合问题 谈起Spring必然离不开 IOC 和AOP IOC–控制反转 核心是DI(依赖注入) 何为反转？ 依赖对象的创建和依赖关系的形成，以前是我们主动去new 一个对象，现在 我们把对象交给spring的IOC容器去管理，需要的时候只需注入即可 Bean对象的创建三种方式 1>无参构造 2> 静态工厂 -> factory-method + class 3> 非静态的实例工厂 ->
Spring框架最全知识点
weixin_43515260的博客
09-06 793
Spring框架最全知识点总结
Spring MVC +Spring 框架学习总结-入门必学知识点
d586947的博客
03-24 245
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。 spring相关视频教程：https://www.bilibili.com/video/BV1nz4y1d7uy Spring MVC 是 Spring 提供的一个基于 MVC 设计模式的轻量级 Web 开发框架，本质上相当于 Servlet。Sp
Spring MVC 框架学习总结
最新发布
08-18
**Spring MVC 框架学习总结** Spring MVC 是 Spring 框架的一部分，它是一个用于构建 Web 应用程序的模型-视图-控制器（MVC）架构。Spring MVC 提供了一个灵活、可扩展的环境，使开发者可以专注于业务逻辑，而无需...
Web核心（前端、serverlt）
07-09
javaweb核心 培训笔记 包含前端知识点，web容器知识 黑马笔记
spring框架的知识点总结
猫腻的博客
07-28 318
文章目录什么是Spring框架?什么是Spring?作用如何在快速添加Maven依赖?SpringFramework 5.x核心之IOC容器什么是IOC?案例SpringFramework 5.x核心之DI依赖注入什么是DI?案例Spring5.x bean的作用域和注入Spring 5.x bean的scope作用域讲解Spring 5.x 常见的注入方式使用set方法注入使用带参的构造函数注入特别容易出现的问题List-Map 类型的注入Spring IOC 容器Bean之间的依赖和继承bean继承--
spring框架知识点总结
wodetian1225的博客
01-24 484
1.首先,我们先了解一下,Spring是什么? Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。Spring致力于J2EE应用的各层的解决方案，而不是仅仅专注于某一层的方案。Spring是企业应用开发的“一站式”选择，并贯
Spring框架的知识点
Java小囧子的博客
03-15 533
** 最近在学习java后端技术，目标全栈工程师。整理下Spring框架的知识点 ** Spring介绍 Spring是一个基于IOC和AOP的结构J2EE系统的框架 IOC 反转控制 是Spring的基础，Inversion Of Control 简单说就是创建对象由以前的程序员自己new 构造方法来调用，变成了交由Spring创建对象 DI 依赖注入 Dependency Inject. 简单...
框架系列课程-Spring新版本
热门推荐
qq_16804847的博客
11-23 2万+
spring课程课堂教例
Spring框架重要知识点
青衫
05-14 648
一、Spring的几大核心功能 1.IoC/DI：控制反转/依赖注入 2.AOP：面向切面编程 3.声明式事务 二、IoC 1.中文名称：控制反转 2.英文名称:(Inversion of Control) 3.IoC是什么： （1）IoC：指原先有程序员主动new实例化对象的事情，转交给Spring负责 （2）控制反转中的控制：指控制类的对象 （3）控制反转中的反转：指...
SpringMVC面试知识点总结
lz1170063911的博客
04-07 3215
1.简单的谈一下SpringMVC的工作流程？ 用户发送请求，springMVC的前端控制器DispatcherServlet接收该请求，并根据请求类别交与相对应的Handler处理器进行处理，Handler将该处理结果返回给前端处理器DispatcherServlet，前端处理器DispatcherServlet将处理结果转发给jsp页面，经过视图渲染之后返回给前端控制器DispatcherSe...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值