Coder Social home page Coder Social logo

learning-blog's People

Contributors

gunnersk avatar

learning-blog's Issues

入门

一、数据结构基本概念

  1. 数据项：是不可分割的最小数据单位

  2. 数据元素：是数据的基本单位

  3. 数据对象：是性质相同的数据元素的集合
        图片

二、数据结构

  1. 逻辑结构

    1. 线性结构（有且只有一个开始结点和终端结点，并且所有结点最多有且只有一个直接前驱和直接后继）

    2. 线性表

    3. 栈

    4. 队列

    5. 串和数组

    6. 非线性结构（一个结点可能对应多个直接前驱和直接后驱）

      1. 树

      2. 图

    • 分类2：

      集合结构（数据间没有直接关系，不研究）

      顺序结构（一对一）

      树状结构（一对多）

      网状结构（多对多）

  2. 存储结构

    1. 顺序存储

    2. 链式存储

    3. 索引存储

    4. 散列存储

  3. 数据的运算

    查找、排序、插入、删除、修改等

图片

三、算法

  1. 算法特性

    1. 输入：以待解决的问题作为输入

    2. 输出：输入对应指令集处理后得到的信息

    3. 可行性：每一条指令都能实现，能在有限的时间内完成

    4. 有穷性：执行的指令个数有限，且可以在有限时间内完成

    5. 确定性：对于特性的合法输入，对应的输出是唯一的

  2. 时间复杂度

    1. 时间频度：算法中语句执行的次数，表示为T(n)，n表示问题规模

    2. 时间复杂度：一般知道算法的规模就好了，没必要知道他执行语句的具体次数，引入时间复杂度。时间频度去掉低阶项和首项常数就是时间复杂度 T(n) = O(n)表示时间复杂度

       tips：时间频度不同的时间复杂度可能相同

    3. 最坏时间复杂度和平均时间复杂度：如果不特别说明，一般讨论的都是最坏时间复杂度

    4. 计算方法

      1. 找出基本语句，执行次数最多的就是，通常是内层循环

      2. 只需计算基本语句执行次数的数量级，忽略低次幂和最高次幂的洗漱

    5. 常用时间复杂度级别

      1. 常数阶O(1)

      2. 线性阶O(n)

      3. 线性对数阶O(n*log2n)

      4. 平方阶O(n2)

      5. 立方阶O(n3)

  3. 空间复杂度

    1. S(n) = O(n)表示空间复杂度

    2. 空间复杂度比时间复杂度分析要少

    3. 递归的空间复杂度一般比较高，代码短

java入门基础

一、JDK, JRE, JVM的关系

  1. JDK包含了java编译器、JRE、以及常用的java类库等。

  2. JRE包含了核心虚拟机JVM、其他的类加载器、字节码校验器以及大量的基础类库等运行java程序的其他环境支持。

  3. tips：如果只是运行java程序，只需要JRE就可以了，不用JDK全套。

二、 JDK目录下主要文件夹的作用

  1. bin：存放了各种工具命令，例如 javac, java

  2. jre：运行所需的JRE环境

  3. lib：存放了工具命令的实际执行程序

    1. 例如java.exe就是用java编写的，这个类就是tool.jar文件中sun/tools/javac路径下的Main类。

    2. bin路径下的绝大部分命令都是包装了tool.jar中的工具类

  4. src.zip：存放java所有核心类库的源代码

Spring（二）draft

一、AOP

  1. AOP: 中文名称面向切面编程

  2. 定义：

  3. 常用概念

    1. 切点：pointcut

    2. 前置通知: 在切点之前执行的功能. before advice

    3. 后置通知: 在切点之后执行的功能,after advice

    4. 异常通知：如果切点执行过程中出现异常,会触发异常通知.throws advice

    5. 切面：所有功能总称叫做切面

    6. 织入: 把切面嵌入到原有功能的过程叫做织入

    7. 作用（待完善）：aop都是拦service层方法

  4. spring 提供了 2 种 AOP 实现方式

    1. Schema-based

      1. 每个通知都需要实现接口或类

      2. 配置 spring 配置文件时在aop:config配置

    2. AspectJ

      1. 每个通知不需要实现接口或类

      2. 配置 spring 配置文件是在aop:config的子标签aop:aspect中配置

二、Schema-based 实现步骤

  1. spring的applicationcontext文件头的xmlns属性是引入schema的

  2. 下面通提代码来说明前置、后置、异常、环绕通知的用法，以下是两个类的说明

    1. Demo类作用：用Demo类里的方法来作为切点（相当于service层的方法）

    2. Test类作用：调用Demo类中的方法来测试AOP功能

  3. 前置通知

    1. applicationContext.xml配置文件，applicationcontext文件头的xmlns属性是引入schema的

      1. 通配符的各种用法见下面的代码
         <?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: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">

       <bean id="mybefore" class="cn.gunners.advice.MyBeforeAdvice"></bean>
       <bean id="myafter" class="cn.gunners.advice.MyAfterAdvice"></bean>

     <!-- 配置切面 -->
       <aop:config>
       
       <!-- 配置切点 -->
       
         <!-- 第一个星号表示声明出通配符 -->
         <aop:pointcut expression="execution(* cn.gunners.test.Demo.demo2())" id="mypoint"/>
         
         <!-- 匹配cn.gunners.test.Demo类下所有无参方法 -->
         <aop:pointcut expression="execution(* cn.gunners.test.Demo.*())" id="mypoint"/>
         
         <!-- 匹配cn.gunners.test.Demo任意类型参数的方法 -->
         <aop:pointcut expression="execution(* cn.gunners.test.Demo.*(..))" id="mypoint"/>
         
         <!--匹配cn.gunners.test包下任意方法  -->
         <aop:pointcut expression="execution(* cn.gunners.test.*.*(..))" id="mypoint"/>
         
         <!-- 配置通知 -->
         <aop:advisor advice-ref="mybefore" pointcut-ref="mypoint"/>
         <aop:advisor advice-ref="myafter" pointcut-ref="mypoint"/> 	
       </aop:config>

     <bean id="demo" class="cn.gunners.test.Demo"></bean>

    2. Demo类

         public class Demo{
   
   public void demo4(String name){
     System.out.println("demo4");
   }
 }

    3. Advice类

      1. 可以在前置通知类里获取方法的参数等各种信息，详见以下代码
         public class MyBeforeAdvice implements MethodBeforeAdvice {
   @Override
   public void before(Method arg0, Object[] arg1, Object arg2) 
       throws Throwable {

   //arg0：切点方法对象，Method对象
     System.out.println("ִ切点方法对象："+arg0+",方法名:"+arg0.getName());

   //arg1：切点方法参数
     if(arg1 != null && arg1.length > 0){
       System.out.println("切点方法参数："+arg1[0]);
     }else{
       System.out.println("切点没有参数");
     }

   //arg2：切点在哪个对象中
     System.out.println("对象："+arg2);

     System.out.println("ִ执行前置通知");
   }
 }

    4. Test类

         public class Test {
   public static void main(String[] args) {
     ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
     Demo demo = ac.getBean("demo",Demo.class);
     demo.demo4("传递的参数");
   }
 }

  4. 后置通知

    1. applicationContext.xml配置文件，下面的applicationcontext都省略文件头的xmlns属性

      看前置通知的xml文件

    2. Demo类

         public class Demo{
   
   public void demo4(String name){
     System.out.println("demo4");
   }
   public String demo5(String name){
     System.out.println("demo5");
     return "demo5的返回值";
   }
 }

    3. Advice类

      1. 除了可以获取和前置通知一样的切点方法的信息，还可以获取切点方法的返回值
         public class MyAfterAdvice implements AfterReturningAdvice {
     @Override
     public void afterReturning(Object arg0, Method arg1, Object[] arg2,
         Object arg3) throws Throwable {
     //arg0：切点方法返回值
       System.out.println("arg0:"+arg0);

     //剩下的arg跟前置通知的一样	
       System.out.println("arg1:"+arg1);
       System.out.println("arg2:"+arg2);
       System.out.println("arg3:"+arg3);

       System.out.println("ִ执行后置通知");
     }
   }

    4. Test类

         public class Test {
   public static void main(String[] args) {
     ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
     Demo demo = ac.getBean("demo",Demo.class);
     demo.demo4("传递的参数");
     demo.demo5("demo5的参数");
   }
 }

  5. 异常通知

    1. applicationContext.xml配置文件

         <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
       <!-- 省略文件头的xmlns属性 -->

     <!-- 异常通知 -->

       <bean id="mythrow" class="cn.gunners.advice.MyThrow"></bean>

       <aop:config>
         <aop:pointcut expression="execution(* cn.gunners.test.Demo.demo1())" id="mypoint"/>
         <aop:advisor advice-ref="mythrow" pointcut-ref="mypoint"/>
       </aop:config>

       <bean id="demo" class="cn.gunners.test.Demo"></bean>
   </beans>

    2. Demo类

      在这里面使切点方法出现异常，但是不要在里面try/catch，要使用Throw拦截异常就不要再切点方法里自己捕获异常

         public class Demo{  
     public void demo1() throws Exception{
       int i = 5/0;  //算术异常
       System.out.println("demo1");
     }
   }

    3. Advice类 要实现接口

         public class MyThrow implements ThrowsAdvice {

     //schema-base方式的异常必须实现接口，然后自己写方法（因为schema-base方式在配置切点的时候直接配置异常通知类就好，不用指定异常通知的具体方法，
     //所以只有实现特定的接口了他才知道要用哪个方法，而aspect方式配置切点有手动指定方法，所以不用实现特定接口，这里要区别开来），且必须叫afterThrowing，1个或4个参数
     //异常类型要和切点报的异常类型一致，例如下面的ArithmeticException，这个异常方法只能应用在报ArithmeticException异常的切点

     public void afterThrowing(ArithmeticException ex) throws Throwable {
          System.out.println("执行异常通过-schema-base方式");
       }

     public void afterThrowing(Method m, Object[] args, Object target, Exception ex) {
       System.out.println("执行异常通知");
       }
   }

    4. Test类

         public class Test {
     public static void main(String[] args) {
       ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
       Demo demo = ac.getBean("demo",Demo.class);
       try {
         demo.demo1();
       } catch (Exception e) {
   //			e.printStackTrace();
       }
     }
   }

  6. 环绕通知

    1. applicationContext.xml配置文件

         <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
       <!-- 省略文件头的xmlns属性 -->

     <!-- 环绕通知 -->

       <bean id="myarround" class="cn.gunners.advice.MyArround"></bean>

       <aop:config>
         <aop:pointcut expression="execution(* cn.gunners.test.Demo.demo1())" id="mypoint"/>
         <aop:advisor advice-ref="myarround" pointcut-ref="mypoint"/>
       </aop:config>

       <bean id="demo" class="cn.gunners.test.Demo"></bean>
   </beans>

    2. Demo类

         public class Demo{  
     public void demo1() throws Exception{
       System.out.println("demo1");
     }
   }

    3. Advice类

         public class MyArround implements MethodInterceptor{

     //环绕通知就是前置后置通知放一起

     public Object invoke(MethodInvocation arg0) throws Throwable {
       System.out.println("环绕-前置");
       Object result = arg0.proceed();//放行，调用切点方式
       System.out.println("环绕-后置");
       return result;
     }

   }

    4. Test类

      调用切点方法就得了

三、AspectJ 实现步骤

  1. 前置通知

  2. 后置通知

  3. 异常通知

    1. applicationContext.xml配置文件

         <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
      <!-- 省略文件头的xmlns属性 -->

       <!-- 先声明异常类MyThrowAdvice -->
       <bean id="mythrow" class="cn.gunners.advice.MyThrowAdvice"></bean>

       <!-- 配置切面，下面必须明确指定异常通知类和异常方法 -->
       <aop:config>

         <!-- 配置aspect异常，引用上面定义的id为mythrow的bean对应的异常通知类 -->
         <aop:aspect ref="mythrow">

           <!-- 配置切点，即作用于哪个切点的异常 -->
           <aop:pointcut expression="execution(* cn.gunners.test.Demo.demo1())" id="mypoint"/>

           <!-- 配置异常，method是上面引入的异常通知类的myexception方法 -->
             <!-- <aop:after-throwing method="myexception" pointcut-ref="mypoint"/>	-->
             <!-- throwing是异常对象名，必须和异常通知类中方法的参数名(异常对象名)相同（也可以不在方法中声明异常对象参数） -->
             <aop:after-throwing method="myexception" pointcut-ref="mypoint" throwing="e"/>	
         </aop:aspect>
       </aop:config>

     <bean id="demo" class="cn.gunners.test.Demo"></bean>
   </beans>

    2. Demo类

      在这里面使切点方法出现异常

         public class Demo{  
     public void demo1() throws Exception{
       int i = 5/0;  //算术异常
       System.out.println("demo1");
     }
   }

    3. Advice类 不用实现接口

         public class MyThrowAdvice {

     //异常通知类的方法的参数名相同必须和xml文件中切点异常的throwing异常对象名一致（也可以不在方法中声明异常对象参数）
     public void myexception(Exception e){
       System.out.println("执行异常通知"+"异常message："+e.getMessage());
     }
   }

    4. Test类

         public class Test {
     public static void main(String[] args) {
       ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
       Demo demo = ac.getBean("demo",Demo.class);
       try {
         demo.demo1();
       } catch (Exception e) {
   //			e.printStackTrace();
       }
   }

  4. 环绕通知

linux环境下nexus的安装

  1. nexus安装与介绍

    1.1 最好新建一个文件夹(建议命名为nexus)，把nexus压缩包的东西解压到这个文件夹底下

    1.2 解压出来有两个文件夹：nexus-2.11.4-01和sonatype-work

    nexus-2.11.4-01：这个文件夹里面有个nexus文件夹，里面是一个java编写的web项目，是本地私服
                            对开发人员提供的一个网页面板

sonatype-work：这个文件夹是工作目录，其实就是仓库。私服从**仓库下载的东西就放在这个文件夹
                           maven项目就从这个文件夹里下载东西

  2. 配置nexus

    2.1. 修改防火墙，开放nexus私服端口访问

     2.1.1 查看防火墙，可以看到只开放了22端口   service iptables status   

 2.1.2 因为nexus要用8081端口，所以还要给他在iptables文件里添加8081端口
         编辑iptables文件：vi /etc/sysconfig/iptables
         添加8081端口：复制粘贴这一行，把22改成8081即可
                               -A INPUT -m state --state NEW -m tcp -p tcp --dport 22(8081) -j ACCEPT

 2.1.3 然后重启防火墙：service iptables restart

 2.1.4 再次查看防火墙：service iptable status  可以看到多了个8081端口
         然后就把防火墙关掉，自己的虚拟机都关掉防火墙  service iptables stop

  3. 启动nexus

    切换到/usr/local/nexus/nexus-2.11.4-01/bin目录

    启动nexus：./nexus start

    查看nexus状态：./nexus status 可查看其pid号(进程号)

    停止nexus：./nexus stop

    访问nexus首页：IP地址+端口号(8081)+nexus

  4. 登录nexus

    4.1 账号密码

        默认登录账号：admin 
    
    默认登录密码：admin123
              
                     可在security--Users中修改用户信息

    4.2. 检查仓库

        在Views/Repositories--Repositories 可查看仓库信息 
    
    4.2.1 仓库类型Type简述：

            4.2.1.1 group(仓库组)         nexus通过仓库组来管理各种仓库，访问仓库组等于访问他管理的各种仓库  
            
            4.2.1.2 hosted(宿主仓库) 
                       1. releases          发布版本
                       2. snapshots       快照版本
                       3. 3rd party 
            
            4.2.1.3 proxy(代理仓库)  
                        在Central仓库下面的configuration中的 download remote indexes 改为true 按save保存
                        表示允许远程下载，把远程仓库中的所有文件都下载到本地        
            
            4.2.1.4 virtual(虚拟仓库)      前三个较常用

            注意：1.**仓库更新，nexus私服的东西也跟着更新，不过不是自动更新，是触发更新，就是maven项目
                         访问私服需要下载某个项目的时候，私服发现这个索引不存在，就会自动更新。
                      2.索引库就是jar包

  5. 配置maven的settings.xml文件

    5.1 在settings文件中配置私服信息

       修改maven的setting.xml配置文件，在<service>标签中添加以下几个server信息
   
   5.1.1 tomcat的server信息，原来有的就不用加了
           <server>
                 <id>tomcat7</id>
                 <username>tomcat</username>
                 <password>tomcat</password>
           </server>

   5.1.2 nexus信息，id自定义，自己记住
           <server>
                 <id>nexus-releases</id>                            
                 <username>deployment</username>
                 <password>deployment123</password>
           </server>

   5.1.3 nexus信息，id自定义，自己记住
           <server>
                 <id>nexus-snapshots</id>
                 <username>deployment</username>
                 <password>deployment123</password>
           </server>

   username 和 password用nexus里面提供的，在User里面查看，可在User里面Add添加用户

   5.1.4 profile标签，详见maven的settings.xml文件

   5.1.5 settings.xml文件不能带中文字符，否则eclipse不能导入配置文件
           settings.xml文件只需配置一次，所有maven工程都可以通用

  6. 配置maven工程的pom文件

       此pom文件在maven的顶级父工程中定义，所有子工程自动依赖导入
    org.springframework spring-context 4.1.6.RELEASE 
     <distributionManagement>
 	<repository>
 		<id>nexus-releases</id>
 		<name>Nexus Release Repository</name>
 		<url>http://192.168.1.105:8081/nexus/content/repositories/releases</url>
 	</repository>
 	<snapshotRepository>
 		<id>nexus-snapshots</id>
 		<name>Nexus Snapshot Repository</name>
 		<url>http://192.168.1.105:8081/nexus/content/repositories/snapshots</url>
 	</snapshotRepository>
 </distributionManagement>

     			<!-- 这是一个向本地私服上传的东西提供源代码信息的插件
 			没有这个插件就只有提供jar包，字节码，没有源代码信息 -->
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-source-plugin</artifactId>
 				<version>2.1.2</version>
 				<executions>
 					<execution>
 						<id>attach-sources</id>
 						<goals>
 							<goal>jar</goal>
 						</goals>
 					</execution>
 				</executions>
 			</plugin>
 	</plugins>

  7. 离线手动安装索引库

    7.1 在4.2.1.3中，如果允许远程下载索引，由于文件比较大，下载速度会很慢，这时可以提前先把文件下载下来，然后再安装进去

       步骤：  
             1. 下载以下三个文件放在一个文件夹zip(命名随意)
                                      nexus-maven-repository-index.gz   (http://repo.maven.apache.org/maven2/.index/最下面)
                                      nexus-maven-repository-index.properties  (http://repo.maven.apache.org/maven2/.index/最下面)
                                      indexer-cli-5.1.1  (百度自己找)
                                      Java -jar indexer-cli-5.1.1.jar -u nexus-maven-repository-index.gz -d indexer

             2. 切换到zip目录，执行Java -jar indexer-cli-5.1.1.jar -u nexus-maven-repository-index.gz -d indexer
                 文件较大，需要等待大约10分钟左右的解压过程，解压完成后停止nexus服务

             3. 删除\nexus\sonatype-work\nexus\indexer\central-ctx 中内容，把解压后indexer文件夹中内容复制到
                 /nexus/sonatype-work\nexus\indexer\central-ctx 中，启动nexus

    7.2 索引安装完之后就Run as--install


8. 发布本地工程到nexus

8.1 只能发布到宿主仓库(Type为hosted的仓库)

      8.1.1 如果版本号以SNAPSHOT结尾的就会发布到快照库

      8.1.2 不以SNAPSHOT结尾的发布到Releases库

      8.1.3 第三方库必须手工上传，无法通代码发布，在3rd party底下的Artifact Upload那里挨个上传

8.2 以deploy(部署)命令run maven项目
     
      注意：同一个版本的项目在同一个库(比如Releases)中只能发布一次，多次发布需要修改nexus配置
                在对应库的Configuration中设置Allow Redeploy

8.3 install作用

      8.3.1 扫描pom文件里的所有依赖，如果依赖在本地仓库不存在，会访问私服或者镜像仓库，然后再下载

      8.3.2 把jar包安装到本地仓库

git的eclipse使用

  1. eclipse生成ssh key，会生成两个文件，默认保存在系统盘中，一定要保存在系统盘里，不能更改
    .pub结尾的文件，表示公钥，给外人用的，没有.pub表示秘钥，给自己用

****

  1. 打开pub文件，复制里面的内容，作为github中的一个新增的ssh的key

3.Team--git--Configuration--Add Entry
entry1: key=http.sslVersion
value=tlsv1.2
entry2: key=user.name
value=gunners_K
entry23: key=user.email
value=

  1. 克隆、拉取一个git仓库
    克隆
    url：复制git中仓库的url
    user&password：git的账户和密码
    拉取
    在克隆下来的仓库里，选择要拉取的项目，右键--import
    在eclipse.ini中定义TLSv1.1&1.2，表示支持这两个版本的协议

eclipse默认只支持TSL协议(http加密协议)只有1.0和1.1版本，要让他支持1.2版本，能正常访问github，
需要修改eclipse.ini文件，在最后添加这句代码-Dhttps.protocols=TLSv1.1,TLSv1.2

增加和提交内容
5. 创建一个本地工程，右键Team--share project，选中本地仓库，finish
如果创建的本地工程不是远程或本地仓库，工程会有一个问号的图标显示NO-HEAD，即在本地仓库找不到头信息

  1. 项目右键team--commit--勾选要提交到本地仓库的文件
    --点击commit and push 表示把工程同步保存到本地仓库，同时把本地仓库的信息同步更新到远程仓库(github网站)
    --点击commit 表示只把工程同步保存到本地仓库
    这时候工程会有一个圆柱的图标，表示工程目录与本地仓库一一对应，已经同步成功
    如果圆柱变成>号则表示工程被修改，与本地仓库的不统一，还没更新到本地仓库
    这时候需要右键--team--commit，把项目或文件提交更新到本地仓库

  2. 如果修改了项目，只是提交修改到本地仓库，项目后面会有向上的箭头和一个数字x，表示有x步操作未同步到远程仓库
    右键team--commit--commit and push将修改提交到远程仓库可解决
    也可以右键team--remote--push
    如果是向下的箭头和一个数字，则表示项目比远程仓库少东西，较少见
    总之提交可分为两种：
    一种是分为两步，先提交到本地仓库，再提交到远程仓库
    一种是只提交到本地仓库

更新内容
更新内容指的是从远程下载到本地

  1. 本地仓库和远程仓库都有HEAD头信息，相当于目录，索引
    fetch：拉取远程版本库中的变化信息，将远程仓库中最新版本的头信息更新到本地仓库，不包含具体内容
    pull：把远程仓库的头信息和内容都更新到本地仓库
  2. 项目修改后想提交到仓库跟增加和提交内容的做法一样

分支管理

  1. 新建分支切换分支：右键项目--team--switch--可以新建分支，灰色代表当前选中分支
  2. 右键项目--team--push branch xxx 把分支更新到远程仓库
  3. 合并分支：切换到主干之后右键项目--team--merge，选择要合并的分支，点击merge进行合并，之后pull提交到远程仓库
  4. 删除分支
    本地分支：右键项目--team--advanced--delete branch 选择要删除的分支，尽量不要删除主干master
    远程分支：右键项目--team--remote--push--next 在remote ref to delete那里选择要删除的分支--add spec--next

冲突管理

  1. 右键项目--team--synchronize workspace
  2. 之后再在提交出现冲突的那个工程里右键项目--team--pull，把他改成想要的内容
  3. 改完之后把他加入到HEAD索引信息里面，右键项目--team--add index，再commit

删除内容

  1. 删除文件：把文件删除后commit即可
  2. 删除工程：把工程删除后，在git repository中右键commit，即可把远程仓库删除

还有忽略文件没看

Spring（一）

一、Spring简介

  1. Spring核心功能（必须弄明白，面试就问这三个）

    1. IoC/DI   控制反转/依赖注入

    2. AOP   面向切面编程

    3. 声明式事务

  2. Spring 框架中重要概念

    1. 把Spring 当作一个大容器

    2. BeanFactory 接口是老版本

      1. 新版本中 ApplicationContext 接口，是 BeanFactory 子接口，BeanFactory 的功能在ApplicationContext 中都有

    3. 从 Spring3 开始把 Spring 框架的功能拆分成多个 jar，Spring2 及以前就一个 jar

二、IoC（控制反转）

  1. IoC是什么：将程序员主动通过new实例化对象的事情转交给spring负责

  2. IoC最大的作用：解耦

三、spring创建对象的三种方式

  1. 通过构造方法创建

    1. 无参构造创建（默认情况）

    2. 有参构造创建，需要明确配置

      1. 指定参数（通过这三个参数精确定位到哪个构造方法的参数，以确定使用哪个构造方法）

        1. index 参数的索引，从0开始

        2. name 参数名

        3. type 数据类型

      2. 给参数赋值

        1. ref 参数是实体类的用ref定义，表示引用另一个bean

        2. value 基本数据类型或string用value

    tips：如果设定的条件匹配多个构造方法，则执行最后的构造方法

  2. 实例工厂

    1. 先要有一个实例工厂类PeopleFactory
    public class PeopleFactory {
 //实例工厂方法
 public People newInstance(){
 	return new People(1,"测试");
 }
}
    1. 然后在applicationContext.xml 文件中配置工厂对象和需要创建的对象
     <bean id="factory" class="cn.gunners.pojo.PeopleFactory"></bean>
 <bean id="peo1" factory-bean="factory" factory-method="newInstance"></bean>

  3. 静态工厂

    1. 不需要创建工厂，直接快速创建需要的对象

      1. 编写一个静态工厂(在方法上添加 static)
      public class PeopleFactory {
//静态工厂方法
  public static People newInstance(){
  	return new People(1,"测试");
  }
}
      1. 在 applicationContext.xml 中
      <bean id="peo2" class="cn.gunners.pojo.PeopleFactory" factory-method="newInstance"></bean>

四、给 Bean 的属性赋值(注入)

set赋值(注入)走的是set方法

public class People {
	private int id;
	private String name;
	private Set<String> sets;
	private List<String> list;
	private String[] strs;
	private Map<String, String> map;
	private Desk desk;
}
  1. 基本数据类型及String
    <bean id="peo" class="cn.gunners.pojo.People">
   	<!-- 两种写法 -->
    	<property name="id" value="222"></property>
    	<property name="name">
    		<value>张三</value>
    	</property>
    </bean>
  1. set集合
    <bean id="peo" class="cn.gunners.pojo.People">
          <property name="sets">
	    	<set>
	    		<value>1</value>
	    		<value>2</value>
	    		<value>3</value>
	    		<value>4</value>
	    	</set>
          </property>
    </bean>
  1. list集合
    <bean id="peo" class="cn.gunners.pojo.People">
          <property name="list">
	    	<list>
	    		<value>1</value>
	    		<value>2</value>
	    		<value>3</value>
	    	</list>
	    </property>
    </bean>
	   <!-- 如果list中只有一个值，还可以这么写，以后list如果只有一个值经常这么写-->
		   <!-- <property name="list" value="1">
		   </property> -->
  1. 数组
    <bean id="peo" class="cn.gunners.pojo.People">
          <property name="strs">
	    	<array>
		    	<value>1</value>
		    	<value>2</value>
		    	<value>3</value>
		</array>
	    </property>
    </bean>
	<!-- 如果数组中只有一个值，也可以跟list一样的写法-->
		<!-- <property name="strs" value="测试">
		</property> -->
  1. map集合
    <bean id="peo" class="cn.gunners.pojo.People">
          <property name="map">
	    	<map>
		    	<entry key="a" value="b"></entry>
		    	<entry key="c" value="d"></entry>
		</map> 
	  </property>
    </bean>
  1. properties类型
    <bean id="peo" class="cn.gunners.pojo.People">
          <property name="demo">
	    	<props>
		    	<prop key="key">value</prop>
		    	<prop key="key1">value1</prop>
		</props>
	  </property>
    </bean>
  1. 实体类对象（也就是第五点：依赖注入）
        <bean id="desk" class="cn.gunners.pojo.Desk">
    	    <property name="id" value="1"></property>
    	    <property name="price" value="12"></property>
        </bean>
	<!-- 只需在文件中定义一个实体类的bean，与本bean的前后顺序无关 -->
	<property name="desk" ref="desk"></property>

五、DI（依赖注入）

  1. 当一个类(A)中需要依赖另一个类(B)对象时,把 B 赋值给 A 的过程就叫做依赖注入
        <bean id="desk" class="cn.gunners.pojo.Desk">
    	    <property name="id" value="1"></property>
    	    <property name="price" value="12"></property>
        </bean>
	<!-- 只需在文件中定义一个实体类的bean，与本bean的前后顺序无关 -->
	<property name="desk" ref="desk"></property>

六、spring整合mybatis（简单整合）

  1. applicationContext.xml文件：
        <bean id="dataSouce" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
		<property name="url" value="jdbc:mysql://193.112.78.108:3306/ssm"></property>
		<property name="username" value="root"></property>
		<property name="password" value="MYchen135136137"></property>
	</bean>

	<!-- 创建SqlSessionFactory对象 -->
	<bean id="factory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 数据库连接信息来源于dataSource -->
		<property name="dataSource" ref="dataSouce"></property>
	</bean>

	<!-- 扫描器：相当于mybatis.xml中mappers下的package标签，扫描cn.gunners.mapper包后会给对应接口创建对象 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<!-- 要扫描哪个包 -->
		<property name="basePackage" value="cn.gunners.mapper"></property>
		<!-- 和factory产生关系 -->
		<property name="sqlSessionFactory" ref="factory"></property>
	</bean>
	
        <!-- 管理AirportServiceImpl实现类，并为其mapper设值注入 -->
	<bean id="airportService" class="cn.gunners.service.impl.AirportServiceImpl">
		<property name="airportMapper" ref="airportMapper" ></property>
	</bean>

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.