企业级开发框架总结

最新推荐文章于 2024-07-11 20:32:24 发布

道山_靓仔

最新推荐文章于 2024-07-11 20:32:24 发布

阅读量1.1k

点赞数 1

本文链接：https://blog.csdn.net/qq_36326116/article/details/96360314

版权

post:
参数传递：@RequestBody,参数封装在control成一个对象；有请求体
get:
传参地址栏可以看到；无请求体

@Transacitional(事务)

单例模式：默写懒汉；恶汉
冒泡排序：
函数的内存加载

1.SSM框架（掌握）
   |--sql语句（左外连接（掌握），右外连接（了解））
       书写
   |--spring注解，aop,di,aop……
   |--springMVC 项目的应用
2.redis（了解）
   Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库。它通过提供多种键值数据类型来适应不同场景下的存储需求
   字符串类型
   散列类型
   列表类型
   集合类型
   有序集合类型

3.多线程（了解）
新建状态:
使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。

就绪状态:
当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待线程调度器的调度。

运行状态:
如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程可以变为阻塞状态、就绪状态和死亡状态。

   阻塞状态:
   如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。
       等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
       同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

   死亡状态:
   一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。可用stop和destory函数强行终止

   线程的优先级：
   *每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。
   *Java 线程的优先级是一个整数，其取值范围是 1-10
   *线程优先级不能保证线程执行的顺序，而且非常依赖于平台

   创建一个线程
       通过实现 Runnable 接口；
       通过继承 Thread 类本身；

4.java基础（掌握）
5.java底层（掌握）
6.设计模式（个别掌握）
   单例模式：
       懒汉式：
           public class Singleton {
               private static Singleton instance;
               private Singleton (){}
               public static synchronized Singleton getInstance() {
               if (instance == null) {
                   instance = new Singleton();
                   }
               return instance;
               }
           }
       饿汉式：
           public class Singleton {
               private static Singleton instance = new Singleton();
               private Singleton (){}
               public static Singleton getInstance() {
               return instance;
               }
           }
       双检锁/双重校验锁：
           public class Singleton {
               private volatile static Singleton singleton;
               private Singleton (){}
               public static Singleton getSingleton() {
               if (singleton == null) {
                   synchronized (Singleton.class) {
                   if (singleton == null) {
                       singleton = new Singleton();
                   }
                   }
               }
               return singleton;
               }
           }

7.算法（掌握常用的）
   |--选择   不稳定
   |--冒泡稳定
   |--二分查找
8.博客（掌握）
9.maven的使用（掌握）

7.16
Spring知识点：
   Spring核心容器：引入外部配置文件
       BeanFactory：BeanFactory bean=new XmlBeanFactory(new FileSystemResource("配置文件路径"))
       ApplicationContext：
           ClassPathXMLApplicationContext：ApplicationContext app=new ClassPathXMLApplicationContext("配置文件名称"))
           FileSystemXMLApplicationContext：ApplicationContext app=new FileSystemXMLApplicationContext("配置文件名称"))
   依赖注入：DI-由容器动态的将某个依赖关系注入到组件之中
   控制反转：IOC-对象的创建并不是由调用者来创建而是由Spring容器来创建

   bean的配置属性或子元素名称：常用的
       id:bean的唯一标识
       name:spring容器可以通过该属性对bean管理和配置
       class:bean的具体实现类
       scope:设置bean的作用域（单例，原型...）
       <constructor-arg>:子元素，传入构造参数实例化
       <property>:子元素，用于调用bean实例中的setter方法完成属性赋值，从而完成依赖注入
       ref:<property>,<constructor-arg>等元素的属性或子元素，用于bean工厂中Bean实例的引用
       <list>,<map>,<set>:用于该类型的属性注入

   bean的实例化：
       构造器实例化：通过bean对应类中默认的无参构造方法来实例化
           public class test{
           }
           <bean id="bean1"class="com.c.test">
       静态工厂方式实例化：在bean对应类中加入静态方法返回该创建的对象
           public class test{
               public static test createBean(){
                   return new test();
               }
           }
           <bean id="bean1"class="com.c.test" factory-method="createBean">
       工厂实例化：不用静态方法创建Bean,直接采用创建bean 的方式
           public class test{
               public test createBean(){
                   return new test();
               }
           }
           <bean id="bean1"class="com.c.test" factory-method="createBean">

   bean的作用域：
       singleton:对所有bean的请求，只要id一样，都返回该共享的bean
       prototype:spring容器对每个该bean的请求都创建一个新的实例

   bean的装配：
       基于XML方式：
           (构造注入和设置注入)
           *bean类必须提供一个默认的无参构造方法
           *bean类必须为需要注入的属性提供对应的setter方法
       基于Annotation的装配：
           @Component:泛化的概念仅仅表示一个组件，可以作用任何层次
           @Repository:用于数据访问层
           @Service：作用在业务层
           @Controller:作用在控制层
           @Autowired:配合对应的注解处理器完成bean的配置工作，默认按照bean的类型装配
           @Resource:按照bean的实例名称装配
                   属性：type:bean的类型；name:bean实例的名称。
           推荐使用context命名空间，通知spring扫描指定包下所有bean类。
           <contex: component-scan base-package="bean所在包的路径">
       自动装配：
           使用<bean>标签里边的autowire="byName"属性完成。

   AOP:面向切面编程，采取横向抽离机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或运行时，再将这些提取出来的代码
       应用到所需要执行的地方。
       JDK动态代理：创建代理类需要实现InvocationHandler接口，并编写代理方法，使用的动态代理对象必须实现一个或多个接口。
       CGLIB代理：实现MethodInterceptor接口，对指定的目标类生成一个子类，并对子类进行增强。
       Spring默认使用的是JDK动态代理

       AspectJ:基于java语言的AOP框架
           基于XML：
           //定义切面bean
           <bean id="myAspect" class="包名+类名">
           <aop:config>
               //配置切面
               <aop:aspect id="aspect" ref=",myAspect">
                   //配置切入点
                   <aop:pointcut expression="execution(*....)" id="myPointCut">
                   //配置通知
                   //前置
                   //后置
               </aop:aspect>
           </aop:config>
           基于注解声明：
               @Aspect，@Component声名在切面类上
               在切面类中定义切入点表达式：
               @Pointcut("execution(*....)")
               //使用返回值为void，方法体为空的方法命名切入点
               private void myPointCut(){}
               //前置通知
               @Before(myPointCut())

   Spring JDBC:
       在XML文件文件中：
           1.配置数据源dataSource
           2.使用数据源配置JDBC模板jdbcTemplate
           3.配置注入类，使用JDBC模板

       Spring JdbcTemplete的常用方法：
           execute():创建数据库
           update():增删改
           query():数据库表的查询操作
   Spring事务管理：
       1.配置数据源dataSource,
       2.使用数据源配置JDBC模板jdbcTemplate
       3.配置注入类，使用JDBC模板
       4.事务管理器，依赖数据源
       5.注册事务管理驱动/开启事务注解
       在***Impl实现类上边使用@Transactional注解


7.15

MyBaties知识点：
   MyBaties操作步骤；
       1)配置mybatis-config.xml 全局的配置文件 (1、数据源，2、外部的mapper)
       2)创建SqlSessionFactory
       3)通过SqlSessionFactory创建SqlSession对象
       4)通过SqlSession操作数据库（增删改查，提交事务）
   namespace:统一命名空间，定义没有限制，只要不重复即可，如果想要使用Mybaties的动态代理，需要写DAO接口的全路径名;
   常用的标签：
   ***mapper.xml:
       <mapper namespace="包名+sql文件映射名">
           //查询
           <select id="find_byID" parameterType="Integer" resultType="po.User">
               select * from t_user where id=#{id}
           </select>
           //模糊查询
           <select id="find_byName" parameterType="String" resultType="po.User">
               //select * from t_user where username like '%${value}%'
               //防止SQL注入问题
               //${}表示拼接SQL的字符串，不加解释的原样输出，无法防止SQL注入问题;
               //#{} 只是表示站位，与参数的名字无关，如果只有一个参数，会自动对应。
               select * from t_user where username like concat('%',#{value},'%')
           </select>
           //添加
           <insert id="addUser" parameterType="po.User">
               insert into t_user(name,phone) values(#{name},#{phone})
           </insert>
           //更新
           <update id="update_User" parameterType="po.User">
               update t_user set name=#{name},phone=#{phone}
                   wher id=#{id}
           </update>
           //删除
           <delete id="delete_user" parameterType="Integer">
               delete from t_user where id=#{id}
           </delete>
       </mapper>
   MyBatis的核心对象：
       SqlSessionFactory:在读取配置文件后，通过SqlSessionFactoryBuilder对象来构建，主要是创建SqlSession.
       SqlSession:主要是执行持久化操作；
                   包含了许多数据库操作的方法：
                       最常用的：
                           statement：调用的时候可以通过在mapper中定义的别名+sql语句设置的id调用sql语句
                           selectOne(String statement,Object parameter):查询结果一条对象
                           List selectList(String statement,Object parameter):查询到的是对象的集合（在模糊查询中返回的是一个集合）
                           int insert(String statement,Object parameter):插入方法后返回所影响的行数
                           int update(String statement,Object parameter):更新一条数据，返回影响的行数
                           int delete(String statement,Object parameter):删除一条数据，返回影响的行数
   配置文件：
       根元素：<configuration>:子元素在书写的时候按照顺序写
           常用的子元素：
               <properties>：内部的配置外在化，连接数据可的文件db.properties在外边书写，通过该标签引入连接数据库的文件
               <typeAliases>：type是需要被设置的别名的类，alisa定义的别名。可以引入<package>来自动扫描包定义别名
               <environments>：环境配置（MySql...）,在该标签里边配置事务管理和数据源
               <mappers>：指定MyBatis的映射文件位置
   映射文件：
       主要元素：
           根元素<mapper>:
               常用的子元素：
                   <select>:
                       常用属性：
                           id:命名空间唯一标识符，常与命名空间一起使用；要求id和mapper接口中的方法的名字一致
                           parameterType:传递的参数类型
                           resultType：将结果集映射为java的对象类型。必须（和 resultMap 二选一）
                   <insert>:id,parameterType
                   <update>:id,parameterType
                   <delete>:id,parameterType
                   <sql>：定义可重用的代码段
                   <resultMap>:当数据表中的列名和对象中的属性名完全不一样时，查询的结果数据还是封装到对象中。
   动态SQL:
       <if>:
           <select id="find_byName" parameterType="po.user" resultType="po.user">
           select *from user where 1=1
               <if test="username != null and username !='' ">
                   and username like concat('%',#{username},'%')
               </if>
               <if test="jobs !=null and jobs!=''">
                   and jobs=#{jobs}
               </if>
           </select>

       <choose>,<when>,<otherwise>:当第一个<when>元素为真时，则只动态组装第一个<when>的sql片段。都不满足执行<otherwise>
           select *from user where 1=1
           <choose>
               <when test="username != null and username !='' ">
                   and username like concat('%',#{username},'%')
               </when>
               <when test="jobs != null and jobs !='' ">
                   and jobs=#{jobs}
               </when>
               <otherwise>
                   and phone is not null
               </otherwise>
           </choose>

       <where>,<trim>:<where> 将映射文件的where 1=1 删除用<where> 替代；
                   <trim>:属性prefix表示语句的前缀，，prefixOverrides表示需要去除的字符串
           <select id="find_byName" parameterType="po.user" resultType="po.user">
           select *from user
           <where>
               <if test="username != null and username !='' ">
                   and username like concat('%',#{username},'%')
               </if>
               <if test="jobs !=null and jobs!=''">
                   and jobs=#{jobs}
               </if>
           </where>
           </select>
       <trim>:等价于上边的where
           <select id="find_byName" parameterType="po.user" resultType="po.user">
           select *from user
           <trim prefix="where" prefixOverrides="and">:
               <if test="username != null and username !='' ">
                   and username like concat('%',#{username},'%')
               </if>
               <if test="jobs !=null and jobs!=''">
                   and jobs=#{jobs}
               </if>
           </trim>
           </select>

       <set>:只更新所需更新的字段，而不必把对象的所有属性都更新
           <update id="find_byName" parameterType="po.user">
           update user
               <set>
                   <if test="username != null and username !='' ">
                   and username like concat('%',#{username},'%')
                   </if>
                   <if test="jobs !=null and jobs!=''">
                       and jobs=#{jobs}
                   </if>
                   <if test="phone !=null and phone!=''">
                       and phone=#{phone}
                   </if>
               </set>
           where id=#{id}
           </update>

       <foreach>:传递的参数是集合，不用一条一条的手动去查询
           <select id="find_byName" parameterType="List" resultType="po.user">
               select * from user where id in
                   <foreach item="id" index="index" collect="list" open="("separator","close=")">
                       #{id}
                   </foreach>
           </select>

       <bind>:用于参数的赋值，有利于项目的移植
           <select id="find_byName" parameterType="List" resultType="po.user">
               <bind name="pattern_username" value="'%'+_username">
                   select * from user
                       where username like #{pattern_username}
           </select>
   关系映射：
       一对一：A类中定义的有B类类型的属性，B类中定义的有A类类型的属性
       一对多：A类中定义的有多个B类类型的属性...
       多对多：A类中定义的有B类的集合，....

           一对一：
               嵌套查询：
                   使用resultMap的association标签引入另外一条sql语句
               嵌套结果：
                   使用嵌套的结果映射来处理
           一对多喝多对多：
                   使用的是resultMap的collection变迁来实现

7.16
SpringMVC：
   工作流程：
   DispatcherServlet:前端控制器，在web.XML文件中配置。主要在初始化时加载springmvc-config配置文件
   注解：
       @RequestMapping:标注在方法上时，该方法会在程序接受到对应的url请求是被调用。
                       标注在一个类上边时，该类中的所有方法都将映射为相对于类级别的请求。
   请求处理方法的参数和返回值类型：
       主要有：ModelAndView(返回一个视图)，void,String...
   ViewResolver:视图解析器，用来将路径简化。
   拦截器：（了解）

7.16
   文件上传：
       *form表单的method属性为post
       *form表单的enctype属性为multipart/form-data
       *提供<input type="file" name="filename">的文件上传输入框
       然后在controller中编写上传的方法；在springmvc配置文件中配置文件上传解析器
   文件下载：
       *在客户端使用一个下载的超链接，该链接的href属性要指定后台文件下载的方法以及文件名
       *在controller中使用springmvc提供的文件下载方法进行文件下载
7.16
分页查询:
   *引入依赖
   *添加插件
   *改造userServiceImpl

道山_靓仔

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
企业级开发框架总结

post:参数传递：@RequestBody,参数封装在control成一个对象；有请求体get:传参地址栏可以看到；无请求体@Transacitional(事务)单例模式：默写懒汉；恶汉冒泡排序：函数的内存加载1.SSM框架（掌握） |--sql语句（左外连接（掌握），右外连接（了解））书写 |--spring注解，aop,di,ao...
复制链接

扫一扫