-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathatom.xml
586 lines (312 loc) · 96.6 KB
/
atom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title>JiGW's Blog</title>
<subtitle>春寒料峭 善自珍重</subtitle>
<link href="/atom.xml" rel="self"/>
<link href="http://jigw.top/"/>
<updated>2019-06-08T13:04:29.943Z</updated>
<id>http://jigw.top/</id>
<author>
<name>杂 涅</name>
</author>
<generator uri="http://hexo.io/">Hexo</generator>
<entry>
<title>Mybatis分页插件PageHelper的问题</title>
<link href="http://jigw.top/2019/06/08/Mybatis%E5%88%86%E9%A1%B5%E6%8F%92%E4%BB%B6PageHelper%E7%9A%84%E9%97%AE%E9%A2%98/"/>
<id>http://jigw.top/2019/06/08/Mybatis分页插件PageHelper的问题/</id>
<published>2019-06-08T13:45:13.000Z</published>
<updated>2019-06-08T13:04:29.943Z</updated>
<content type="html"><![CDATA[<h2 id="遇到的问题"><a href="#遇到的问题" class="headerlink" title="遇到的问题"></a>遇到的问题</h2><font color="red">在使用Mybatis的第三方分页插件时，出现了下面的问题</font><pre><code>com.github.pagehelper.PageHelper cannot be cast to org.apache.ibatis.plugin.Interceptor</code></pre><p>具体如图</p><p><img src="https://i.loli.net/2019/06/08/5cfbae47865db77511.png" alt></p><p>附上代码</p><pre><code><!--引入分页助手--><plugins> <plugin interceptor="com.github.pagehelper.PageHelper"> <!--指定方言--> <property name="dialect" value="mysql"/> </plugin></plugins></code></pre><font color="red">此出导入的jar包版本为5.1.2</font><p>关注报错信息发现，PageHelper无法转化为Interceptor,查阅信息，再打开源码查看的确有些端倪</p><p><img src="https://i.loli.net/2019/06/08/5cfbb0d6c41a131692.png" alt><br>有一个PageInterceptor实现了Interceptor接口，再将代码中的PageHelper改为PageInterceptor后，又出现了新问题</p><pre><code>Error parsing SQL Mapper Configuration. Cause: com.github.pagehelper.PageException: java.lang.ClassNotFoundException: mysql</code></pre><p><img src="https://i.loli.net/2019/06/08/5cfbb1773c2db17685.png" alt></p><p>查询信息后了解到，<font color="red">PageHelper插件4.0.0后的版本支持自动识别使用数据库，不用配置方言</font>，因此我将代码改为了如下</p><pre><code><plugins> <plugin interceptor="com.github.pagehelper.PageInterceptor"> </plugin></plugins></code></pre><p>程序正常运行！</p>]]></content>
<summary type="html">
<h2 id="遇到的问题"><a href="#遇到的问题" class="headerlink" title="遇到的问题"></a>遇到的问题</h2><font color="red">在使用Mybatis的第三方分页插件时，出现了下面的问题</font>
<pre><
</summary>
<category term="Mybatis" scheme="http://jigw.top/categories/Mybatis/"/>
<category term="Mybatis" scheme="http://jigw.top/tags/Mybatis/"/>
</entry>
<entry>
<title>${pageContext.request.contextPath}与web.xml问题</title>
<link href="http://jigw.top/2019/06/01/web_xml%E5%A4%B4%E9%97%AE%E9%A2%98/"/>
<id>http://jigw.top/2019/06/01/web_xml头问题/</id>
<published>2019-06-01T11:28:13.000Z</published>
<updated>2019-06-01T16:12:31.825Z</updated>
<content type="html"><![CDATA[<p>在使用idea中的maven-webapp骨架创建web项目时，我的web.xml文件头默认为</p><pre><code><!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd" ><web-app></code></pre><p>之初，配置Spring前端控制器，全局参数…等等，<webapp>标签报红，但这并不影响项目的正常运行，因此也没换成</webapp></p><pre><code><?xml version="1.0" encoding="utf-8"?><web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4"></code></pre><p>但是，在处理SpringMVC请求去获取集合类型参数时，使用了${pageContext.request.contextPath} 表达式，比如下面</p><pre><code><script src="${pageContext.request.contextPath}/js/jquery-3.3.1.js"></script> <script> var userList = new Array(); userList.push({name:"zhangsan",age:23}); userList.push({name:"lisi",age:25}); $.ajax({ type:"post", url:"${pageContext.request.contextPath}/user/success9", data:JSON.stringify(userList), contentType:"application/json;charset=utf-8" }); </script></code></pre><p>报错如下</p><p><img src="https://i.loli.net/2019/06/01/5cf264ea37c8462438.png" alt></p><p>？？？难道使我js路径写的有问题？仔细检查并没有，此时idea控制台并没有报错详细信息。</p><p>再打开f12</p><p><img src="https://i.loli.net/2019/06/01/5cf264f4dce5d41472.png" alt></p><p>再把xml文件头改成上面那个，就好了…这里的version应该在2.4以上，因此在使用${pageContext.request.contextPath}表达式时，web.xml的头应该换成“常规形式”。</p><hr><p>觉得有用不如进入我的<a href="http://jigw.top/comments/">Github博客</a>留个言吧，谢谢支持！</p>]]></content>
<summary type="html">
<p>在使用idea中的maven-webapp骨架创建web项目时，我的web.xml文件头默认为</p>
<pre><code>&lt;!DOCTYPE web-app PUBLIC
&quot;-//Sun Microsystems, Inc.//DTD W
</summary>
<category term="Debug日志" scheme="http://jigw.top/categories/Debug%E6%97%A5%E5%BF%97/"/>
<category term="Spring" scheme="http://jigw.top/tags/Spring/"/>
<category term="xml" scheme="http://jigw.top/tags/xml/"/>
<category term="SpringMVC" scheme="http://jigw.top/tags/SpringMVC/"/>
</entry>
<entry>
<title>一个转账案例-Spring声明式事务全注解开发完成</title>
<link href="http://jigw.top/2019/05/31/Spring%E5%A3%B0%E6%98%8E%E5%BC%8F%E4%BA%8B%E5%8A%A1%E5%85%A8%E6%B3%A8%E8%A7%A3%E5%BC%80%E5%8F%91/"/>
<id>http://jigw.top/2019/05/31/Spring声明式事务全注解开发/</id>
<published>2019-05-31T11:26:13.000Z</published>
<updated>2019-06-01T16:16:22.853Z</updated>
<content type="html"><![CDATA[<h2 id="xml配置文件"><a href="#xml配置文件" class="headerlink" title="xml配置文件"></a>xml配置文件</h2><p>在使用全注解形式去完成转账案例之前，我们先看看在使用纯xml配置的applicationConfiguration.xml</p><pre><code><bean id="accountDao" class="com.xxx.dao.impl.AccountDaoImpl"> <property name="jdbcTemplate" ref="jdbcTemplate"/></bean><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"/></bean><bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"/> <property name="jdbcUrl" value="jdbc:mysql:///account_db"/> <property name="user" value="root"/> <property name="password" value="123456"/></bean><bean id="accountService" class="com.xxx.service.impl.AccountServiceImpl"> <property name="accountDao" ref="accountDao"/></bean><!--配置平台事务管理器 同样要依赖dataSource--><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/></bean><!--通知事务的增强--><!--propagation 事务传播行为REQUIRED：指定当前方法必需在事务环境中运行，如果当前有事务环境就加入当前正在执行的事务环境，如果当前没有事务，就新建一个事务。这是默认值。isolation 事务隔离级别DEFAULT：采用数据库默认隔离级别--><tx:advice id="tx" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="transfer" isolation="DEFAULT" propagation="REQUIRED" read-only="false"/> <tx:method name="find" isolation="DEFAULT" propagation="REQUIRED" read-only="true"/> <tx:method name="*"/> </tx:attributes></tx:advice><!--事务的织入--><aop:config proxy-target-class="true"> <aop:advisor advice-ref="tx" pointcut="execution(* com.xxxservice.impl.*.*(..))"/></aop:config></code></pre><h2 id="全注解形式源码"><a href="#全注解形式源码" class="headerlink" title="全注解形式源码"></a>全注解形式源码</h2><ol start="0"><li><p>建表</p><pre><code>CREATE TABLE account( id INT PRIMARY KEY AUTO_INCREMENT, NAME VARCHAR(20), money DECIMAL);</code></pre></li><li><p>导入所需坐标</p><pre><code><dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.5.RELEASE</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.8.4</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.0.5.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>5.0.5.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>5.0.5.RELEASE</version> </dependency> <dependency> <groupId>c3p0</groupId> <artifactId>c3p0</artifactId> <version>0.9.1.2</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.32</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency></dependencies></code></pre></li><li><p>AccountDaoImpl.java</p><pre><code>@Repositorypublic class AccountDaoImpl implements AccountDao {@Autowiredprivate JdbcTemplate jdbcTemplate;</code></pre></li></ol><pre><code> public void out(String outMan, double money) { jdbcTemplate.update("update account set money=money-? where name=?",money,outMan); } public void in(String inMan, double money) { jdbcTemplate.update("update account set money=money+? where name=?",money,inMan); }}</code></pre><ol start="3"><li><p>AccountServiceImpl.java</p><pre><code>@Service@EnableTransactionManagementpublic class AccountServiceImpl implements AccountService { @Autowired private AccountDao accountDao; @Transactional(isolation = Isolation.DEFAULT,propagation = Propagation.REQUIRED,readOnly = false) public void transfer(String outMan, String inMan, double money) { accountDao.out(outMan,money);// int i = 1/0; accountDao.in(inMan,money); }}</code></pre></li><li><p>SpringConfiguration.java</p><pre><code>@Configuration@ComponentScan("com.xxx")@Import(DataSourceConfiguration.class)public class SpringConfiguration {}</code></pre></li><li><p>DataSourceConfiguration.java</p><pre><code>@Configuration@PropertySource("classpath:jdbc.properties")public class DataSourceConfiguration {</code></pre></li></ol><pre><code> @Value("${jdbc.driver}") private String driverClass; @Value("${jdbc.url}") private String url; @Value("${jdbc.username}") private String user; @Value("${jdbc.password}") private String password; @Bean public DataSource getDataSource() throws PropertyVetoException { ComboPooledDataSource dataSource = new ComboPooledDataSource(); dataSource.setDriverClass(driverClass); dataSource.setJdbcUrl(url); dataSource.setUser(user); dataSource.setPassword(password); return dataSource; } @Bean public JdbcTemplate getTemplate(DataSource dataSource){ return new JdbcTemplate(dataSource); } @Bean public DataSourceTransactionManager getDSTM(DataSource dataSource){ return new DataSourceTransactionManager(dataSource); }}</code></pre><ol start="6"><li><p>jdbc.properties</p><pre><code>jdbc.driver=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql:///account_dbjdbc.username=rootjdbc.password=123456</code></pre></li><li><p>测试</p><pre><code>@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes = SpringConfiguration.class)public class AnnoTest { @Autowired private AccountService accountService; @Test public void test02(){ accountService.transfer("tom","lucy",500f); }}</code></pre></li></ol>]]></content>
<summary type="html">
<h2 id="xml配置文件"><a href="#xml配置文件" class="headerlink" title="xml配置文件"></a>xml配置文件</h2><p>在使用全注解形式去完成转账案例之前，我们先看看在使用纯xml配置的applicationConfig
</summary>
<category term="Spring" scheme="http://jigw.top/categories/Spring/"/>
<category term="Spring" scheme="http://jigw.top/tags/Spring/"/>
<category term="annotation" scheme="http://jigw.top/tags/annotation/"/>
<category term="transaction" scheme="http://jigw.top/tags/transaction/"/>
</entry>
<entry>
<title>Spring注解</title>
<link href="http://jigw.top/2019/05/29/Spring%E6%B3%A8%E8%A7%A3/"/>
<id>http://jigw.top/2019/05/29/Spring注解/</id>
<published>2019-05-29T13:45:13.000Z</published>
<updated>2019-05-31T02:37:29.441Z</updated>
<content type="html"><![CDATA[<h2 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h2><p>初学Spring,相较于xml文件的配置，注解开发的确要简洁的多。但有时还是会忘了一些，故在此整合。</p><h2 id="一般注解列表"><a href="#一般注解列表" class="headerlink" title="一般注解列表"></a>一般注解列表</h2><pre><code>注解 说明@Component 使用在类上用于实例化Bean@Controller 使用在web层类上用于实例化Bean@Service 使用在service层类上用于实例化Bean@Repository 使用在dao层类上用于实例化Bean@Autowired 使用在字段上用于根据类型依赖注入@Qualifier 结合@Autowired一起使用用于根据名称进行依赖注入@Resource 相当于@Autowired+@Qualifier，按照名称进行注入@Value 注入普通属性@Scope 标注Bean的作用范围@PostConstruct 使用在方法上标注该方法是Bean的初始化方法@PreDestroy 使用在方法上标注该方法是Bean的销毁方法</code></pre><p>配置组件扫描</p><pre><code> <!--注解的组件扫描--><context:component-scan base-package="com.xxx"></context:component-scan></code></pre><hr><p>较新的</p><pre><code>@Configuration 用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解@ComponentScan 用于指定 Spring 在初始化容器时要扫描的包。 作用和在 Spring 的 xml 配置文件中的 <context:component-scan base-package="com.itheima"/>一样@Bean 使用在方法上，标注将该方法的返回值存储到 Spring 容器中@PropertySource 用于加载.properties 文件中的配置@Import 用于导入其他配置类</code></pre><p>这里注意非自定义的Bean的配置</p><pre><code>加载properties文件的配置：context:property-placeholder组件扫描的配置：context:component-scan</code></pre><hr><p>Spring集成<font color="red">Junit测试</font>注解</p><p>配置@Runwith、@ContextConfiguration注解<br>这里测试的基本流程为</p><ul><li>导入spring集成Junit的坐标</li><li>使用@Runwith注解替换原来的运行期</li><li>使用@ContextConfiguration指定配置文件或配置类</li><li>使用@Autowired注入需要测试的对象</li><li>创建测试方法进行测试</li></ul><p>Demo</p><pre><code>@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes = {SpringConfiguration.class})public class SpringJunitTest { @Autowired private UserService userService; @Test public void testUserService(){ userService.save(); }}</code></pre><hr><p> 基于<font color="red">AOP</font>开发的注解<br>先了解开发步骤</p><p>①使用<font color="red">@Aspect</font>标注切面类</p><p>②使用@通知注解标注通知方法</p><p>③在配置文件中配置aop自动代理<font color="red"><a href="aop:aspectj-autoproxy/" target="_blank" rel="noopener">aop:aspectj-autoproxy/</a></font></p><p>其中第②步的注解有以下<br><img src="https://i.loli.net/2019/05/31/5cf08952e6ade71571.png" alt></p><h2 id="声明式事务控制的注解开发"><a href="#声明式事务控制的注解开发" class="headerlink" title="声明式事务控制的注解开发"></a>声明式事务控制的注解开发</h2><p>@Transactional 在想要添加事务的方法上使用(可加参数)</p><p>@EableTransactionManagement 注解驱动(相当于annotation-driven,一般放在业务层上)</p><p>@EableAspectJAutoProxy 开启AOP自动代理支持</p>]]></content>
<summary type="html">
<h2 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h2><p>初学Spring,相较于xml文件的配置，注解开发的确要简洁的多。但有时还是会忘了一些，故在此整合。</p>
<h2 id="一般注解列表"
</summary>
<category term="Spring" scheme="http://jigw.top/categories/Spring/"/>
<category term="Spring" scheme="http://jigw.top/tags/Spring/"/>
<category term="annotation" scheme="http://jigw.top/tags/annotation/"/>
</entry>
<entry>
<title>Spring通过DataSource获取数据库数据(非注解方式和注解形式)及Spring集成Junit测试</title>
<link href="http://jigw.top/2019/05/27/Spring%E9%80%9A%E8%BF%87DataSource%E8%8E%B7%E5%8F%96%E6%95%B0%E6%8D%AE%E5%BA%93%E6%95%B0%E6%8D%AE/"/>
<id>http://jigw.top/2019/05/27/Spring通过DataSource获取数据库数据/</id>
<published>2019-05-27T11:16:45.000Z</published>
<updated>2019-05-27T12:52:01.080Z</updated>
<content type="html"><![CDATA[<h2 id="非注解"><a href="#非注解" class="headerlink" title="非注解"></a>非注解</h2><p>这里就不多说了，直接来源码</p><p>1.导入各坐标<br>这里包括数据库连接池(druid/c3p0)，单元测试，数据库连接驱动坐标以及spring的依赖就不一一写出了</p><pre><code><dependencies><dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.5.RELEASE</version></dependency><!--druid连接池--><dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.13</version></dependency></code></pre><p>2.AccountDaoImpl.java</p><pre><code>public class AccountDaoImpl implements AccountDao {private JdbcTemplate template;public void setTemplate(JdbcTemplate template) { this.template = template;}public void findAll(){ List<Map<String, Object>> list = template.queryForList("select * from teacher"); for (Map<String, Object> map : list) { for (String s : map.keySet()) { System.out.println(s+":"+map.get(s)); } } }}</code></pre><p>3.AccountServiceImpl.java</p><pre><code>public class AccountServiceImpl implements AccountService { private AccountDaoImpl accountDao; public void setAccountDao(AccountDaoImpl accountDao) { this.accountDao = accountDao; } @Override public void findAll() { ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); AccountDao accountDao = (AccountDao) applicationContext.getBean("accountDao"); accountDao.findAll(); System.out.println("username:"+username); }}</code></pre><p>4.applicationContext.xml</p><pre><code><bean id="accountDao" class="top.jigw.dao.impl.AccountDaoImpl"> <property name="template" ref="jdbcTemplate"></property> </bean> <bean id="accountService" class="top.jigw.service.impl.AccountServiceImpl"> <property name="accountDao" ref="accountDao"></property> </bean> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSourceFactory" factory-method="createDataSource"> <constructor-arg name="properties"> <props> <prop key="driverClassName">com.mysql.jdbc.Driver</prop> <prop key="url">jdbc:mysql:///test</prop> <prop key="username">root</prop> <prop key="password">123456</prop> </props> </constructor-arg> </bean> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <constructor-arg name="dataSource" ref="dataSource"></constructor-arg> </bean></code></pre><p>5.单元测试</p><pre><code>public class test { @Test public void test01() { ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); AccountService accountService = (AccountService) applicationContext.getBean("accountService"); accountService.findAll(); }}</code></pre><h2 id="注解形式"><a href="#注解形式" class="headerlink" title="注解形式"></a>注解形式</h2><p>1.首先同样是导入坐标</p><p>2.提取jdbc.properties</p><pre><code>jdbc.driver=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql:///testjdbc.username=rootjdbc.password=123456</code></pre><p>3.了解下Spring的一些基本注解吧</p><pre><code>注解 说明@Component 使用在类上用于实例化Bean@Controller 使用在web层类上用于实例化Bean@Service 使用在service层类上用于实例化Bean@Repository 使用在dao层类上用于实例化Bean@Autowired 使用在字段上用于根据类型依赖注入@Qualifier 结合@Autowired一起使用用于根据名称进行依赖注入@Resource 相当于@Autowired+@Qualifier，按照名称进行注入@Value 注入普通属性@Scope 标注Bean的作用范围@PostConstruct 使用在方法上标注该方法是Bean的初始化方法@PreDestroy 使用在方法上标注该方法是Bean的销毁方法@Configuration 用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解@ComponentScan 用于指定 Spring 在初始化容器时要扫描的包。 作用和在 Spring 的 xml 配置文件中的 <context:component-scan base-package="com.itheima"/>一样@Bean 使用在方法上，标注将该方法的返回值存储到 Spring 容器中@PropertySource 用于加载.properties 文件中的配置@Import 用于导入其他配置类</code></pre><p>使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean需要<br>进行扫描以便识别使用注解配置的类、字段和方法。</p><pre><code><context:component-scan base-package="top.jigw"></context:component-scan></code></pre><p>4.AccountDaoImpl.java</p><pre><code>@Repository("accountDao")public class AccountDaoImpl implements AccountDao {private JdbcTemplate template;public void setTemplate(JdbcTemplate template) { this.template = template;}public void findAll(){ List<Map<String, Object>> list = template.queryForList("select * from teacher"); for (Map<String, Object> map : list) { for (String s : map.keySet()) { System.out.println(s+":"+map.get(s)); } } }}</code></pre><p>5.AccountServiceImpl.java</p><pre><code>@Service("accountService")public class AccountServiceImpl implements AccountService { private AccountDaoImpl accountDao; public void setAccountDao(AccountDaoImpl accountDao) { this.accountDao = accountDao; } @Override public void findAll() { ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); AccountDao accountDao = (AccountDao) applicationContext.getBean("accountDao"); accountDao.findAll(); System.out.println("username:"+username); }}</code></pre><p>6.SpringConfiguration.java</p><pre><code>@Configuration@ComponentScan("top.jigw")@Import({DataSourceConfiguration.class})public class SpringConfiguration {}</code></pre><p>7.DataSourceConfiguration.java</p><pre><code>@PropertySource("classpath:jdbc.properties")public class DataSourceConfiguration { @Value("${jdbc.driver}") private String driver; @Value("${jdbc.url}") private String url; @Value("${jdbc.username}") private String username; @Value("${jdbc.password}") private String password; @Bean(name = "dataSource") public DataSource getDataSource(){ DruidDataSource dataSource = new DruidDataSource(); dataSource.setDriverClassName(driver); dataSource.setUrl(url); dataSource.setUsername(username); dataSource.setPassword(password); return dataSource; } @Bean(name = "template") public JdbcTemplate getTemplate(DataSource dataSource){ return new JdbcTemplate(dataSource); }}</code></pre><h2 id="集成Junit测试"><a href="#集成Junit测试" class="headerlink" title="集成Junit测试"></a>集成Junit测试</h2><p>这里需要导入spring-test依赖包</p><pre><code>Spring集成Junit步骤①导入spring集成Junit的坐标②使用@Runwith注解替换原来的运行期③使用@ContextConfiguration指定配置文件或配置类④使用@Autowired注入需要测试的对象⑤创建测试方法进行测试</code></pre><p>SpringJunitTest.java</p><pre><code>@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes = SpringConfiguration.class)public class SpringJunitTest { @Autowired private AccountService accountService; @Test public void testService(){ accountService.findAll(); }}</code></pre>]]></content>
<summary type="html">
<h2 id="非注解"><a href="#非注解" class="headerlink" title="非注解"></a>非注解</h2><p>这里就不多说了，直接来源码</p>
<p>1.导入各坐标<br>这里包括数据库连接池(druid/c3p0)，单元测试，数据库连接驱
</summary>
<category term="Spring" scheme="http://jigw.top/categories/Spring/"/>
<category term="Spring" scheme="http://jigw.top/tags/Spring/"/>
<category term="maven" scheme="http://jigw.top/tags/maven/"/>
<category term="druid" scheme="http://jigw.top/tags/druid/"/>
<category term="junit" scheme="http://jigw.top/tags/junit/"/>
</entry>
<entry>
<title>servlet域对象</title>
<link href="http://jigw.top/2019/05/05/servlet%E5%9F%9F%E5%AF%B9%E8%B1%A1/"/>
<id>http://jigw.top/2019/05/05/servlet域对象/</id>
<published>2019-05-05T12:16:45.000Z</published>
<updated>2019-05-11T06:18:51.415Z</updated>
<content type="html"><![CDATA[<h1 id="引言"><a href="#引言" class="headerlink" title="引言"></a>引言</h1><p>在学习servlet的过程中，数据共享是必须的操作。总的来说，我们要想共享数据往往是利用<font color="pink" size="3"><strong>多个servlet或对象共同操作的一个对象</strong></font>，这类对象称之为<font color="pink" size="3"><strong>作用域</strong></font>。</p><h2 id="HttpServletRequest"><a href="#HttpServletRequest" class="headerlink" title="HttpServletRequest"></a>HttpServletRequest</h2><p>针对<font color="red" size="3"><strong>一次请求</strong></font>。<br>使用该对象保存数据，一次请求(一个页面，如果是请求转发多个页面)内有效。</p><ul><li>创建：客户端想服务器端发送一次请求</li><li>销毁：服务器响应后销毁</li></ul><h2 id="HttpServletSession"><a href="#HttpServletSession" class="headerlink" title="HttpServletSession"></a>HttpServletSession</h2><p>针对<font color="red" size="3"><strong>一次会话</strong></font>。<br>使用该对象保存数据，一次会话(多次请求)有效。</p><ul><li>创建：请求未携带jsessionid时创建session对象，请求携带jsessionid但找不到对应的session时创建session对象。</li><li>销毁：<pre><code>1. 未正常关闭服务器2. 手动调用了Session的invalidate方法3. session过期了，有效时间默认为30分钟</code></pre></li></ul><h2 id="HttpServletContext"><a href="#HttpServletContext" class="headerlink" title="HttpServletContext"></a>HttpServletContext</h2><p>针对<font color="red" size="3"><strong>一个web应用</strong></font>。<br>一个web应用只有一个ServletContext对象，该对象保存的数据对整个web应用都有效。我们可以把ServletContext与其他对象描绘成水和鱼类的关系。</p><ul><li>创建：服务器启动的时候</li><li>销毁：服务器关闭的时候或者项目移除</li></ul><h3 id="三个作用域对象操作的API"><a href="#三个作用域对象操作的API" class="headerlink" title="三个作用域对象操作的API"></a>三个作用域对象操作的API</h3><p>api都是一样的,完成存取和销毁的操作</p><ul><li>存放数据：setAttribute(name,value)</li><li>获得数据：getAttribute(name)</li><li>删除数据：removeAttribute(name)</li></ul><h1 id="小结"><a href="#小结" class="headerlink" title="小结"></a>小结</h1><p>servlet为我们提供的三大域对象来帮助我们实现不同情况下的数据共享,<font color="blue" size="3"><strong>若一个业务功能使用这三个域对象都可以实现,我们一般选用最小的域对象</strong></font>.作用域越小,生命周期越短,在一定程度上可以提供程序的执行效率</p>]]></content>
<summary type="html">
<h1 id="引言"><a href="#引言" class="headerlink" title="引言"></a>引言</h1><p>在学习servlet的过程中，数据共享是必须的操作。总的来说，我们要想共享数据往往是利用<font color="pink" size="3
</summary>
<category term="JavaWeb" scheme="http://jigw.top/categories/JavaWeb/"/>
<category term="servlet" scheme="http://jigw.top/tags/servlet/"/>
<category term="request" scheme="http://jigw.top/tags/request/"/>
<category term="session" scheme="http://jigw.top/tags/session/"/>
<category term="ServletContext" scheme="http://jigw.top/tags/ServletContext/"/>
</entry>
<entry>
<title>事务及隔离级别</title>
<link href="http://jigw.top/2019/05/02/%E4%BA%8B%E5%8A%A1%E5%8F%8A%E9%9A%94%E7%A6%BB%E7%BA%A7%E5%88%AB/"/>
<id>http://jigw.top/2019/05/02/事务及隔离级别/</id>
<published>2019-05-02T07:16:45.000Z</published>
<updated>2019-05-02T06:31:21.021Z</updated>
<content type="html"><![CDATA[<h1 id="事务"><a href="#事务" class="headerlink" title="事务"></a>事务</h1><hr><h2 id="简述"><a href="#简述" class="headerlink" title="简述"></a>简述</h2><p>事务是逻辑上的一组操作，要么都执行，要么都不执行。最简单的；例子如银行转账，双方一人账户增加多少钱，另一人账号就减少多少钱。</p><h2 id="操作"><a href="#操作" class="headerlink" title="操作"></a>操作</h2><pre><code>1. 开启事务： start transaction;2. 回滚：rollback;3. 提交：commit;事务提交的方式： 1. 自动提交 MySQL的提交方式 2. 手动提交 Oracle的提交方式修改事务提交的方式 查看事务的默认提交方式：SELECT @@autocommit; -- 1 代表自动提交 0 代表手动提交 修改默认提交方式： set @@autocommit = 0;</code></pre><h2 id="事务的四个特征"><a href="#事务的四个特征" class="headerlink" title="事务的四个特征"></a>事务的四个特征</h2><ul><li>原子性：是不可分割的最小操作单位，要么同时成功，要么同时失败</li><li>持久性：当事务提交或回滚后，数据库会持久化的保存数据。</li><li>隔离性：多个事务之间。相互独立。</li><li>一致性：事务操作前后，数据总量不变</li></ul><h2 id="事务的隔离级别"><a href="#事务的隔离级别" class="headerlink" title="事务的隔离级别"></a>事务的隔离级别</h2><p>多个事务是相互隔离的、独立的，但多个事务处理同样一批数据时便会发生问题，这时就必须设置隔离级别来解决这些问题。</p><h3 id="存在的问题"><a href="#存在的问题" class="headerlink" title="存在的问题"></a>存在的问题</h3><ul><li>脏读(Dirty Read)：一个事务读取到另一个事务未提交的数据</li><li>不可重复读(虚读)(Unrepeatable Read)：同一个事务中，两次读取的数据不一样。在这个事务还没有结束时，另一个事务也访问该数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改导致第一个事务两次读取的数据可能不太一样。</li><li>幻读(Phantom Read)：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。</li><li>有人也说还有第四种问题-丢失修改(Lost to modify)：指在一个事务读取一个数据时，另外一个事务也访问了该数据，那么在第一个事务中修改了这个数据后，第二个事务也修改了这个数据。这样第一个事务内的修改结果就被丢失，因此称为丢失修改。 例如：事务1读取某表中的数据A=20，事务2也读取A=20，事务1修改A=A-1，事务2也修改A=A-1，最终结果A=18，事务1的修改被丢失。</li></ul><p><strong>不可重复度和幻读区别</strong>：<br>不可重复读的重点是修改，幻读的重点在于新增或者删除。</p><h3 id="隔离级别"><a href="#隔离级别" class="headerlink" title="隔离级别"></a>隔离级别</h3><ul><li><strong>READ-UNCOMMITTED(读取未提交)：</strong> 最低的隔离级别，允许读取尚未提交的数据变更，<strong>可能会导致脏读、幻读或不可重复读</strong>。</li><li><strong>READ-COMMITTED(读取已提交)：</strong> 允许读取并发事务已经提交的数据，<strong>可以阻止脏读，但是幻读或不可重复读仍有可能发生</strong>。</li><li><strong>REPEATABLE-READ(可重复读)：</strong> 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，<strong>可以阻止脏读和不可重复读，但幻读仍有可能发生</strong>。</li><li><strong>SERIALIZABLE(可串行化)：</strong> 最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，<strong>该级别可以防止脏读、不可重复读以及幻读</strong>。</li></ul><p><strong>特点</strong>：安全等级越来越高，但效率越来越低。</p><pre><code>数据库查询隔离级别： * select @@tx_isolation;数据库设置隔离级别： * set global transaction isolation level 级别字符串;</code></pre><h3 id="补充"><a href="#补充" class="headerlink" title="补充"></a>补充</h3><p>在Github上的JavaGuide-master仓库中写到</p><blockquote><p>由 <a href="https://github.com/Snailclimb" target="_blank" rel="noopener">SnailClimb</a> 和 <a href="https://github.com/BugSpeak" target="_blank" rel="noopener">BugSpeak</a> 共同完成。</p></blockquote><pre><code>这里需要注意的是：与 SQL 标准不同的地方在于InnoDB 存储引擎在 **REPEATABLE-READ（可重读）**事务隔离级别下使用的是Next-Key Lock 锁算法，因此可以避免幻读的产生，这与其他数据库系统(如 SQL Server)是不同的。所以说InnoDB 存储引擎的默认支持的隔离级别是 **REPEATABLE-READ（可重读）** 已经可以完全保证事务的隔离性要求，即达到了 SQL标准的**SERIALIZABLE(可串行化)**隔离级别。因为隔离级别越低，事务请求的锁越少，所以大部分数据库系统的隔离级别都是**READ-COMMITTED(读取提交内容):**，但是你要知道的是InnoDB 存储引擎默认使用 **REPEATABLE-READ（可重读）**并不会有任何性能损失。InnoDB 存储引擎在 **分布式事务** 的情况下一般会用到**SERIALIZABLE(可串行化)**隔离级别。</code></pre>]]></content>
<summary type="html">
<h1 id="事务"><a href="#事务" class="headerlink" title="事务"></a>事务</h1><hr>
<h2 id="简述"><a href="#简述" class="headerlink" title="简述"></a>简述</h2><
</summary>
<category term="Database" scheme="http://jigw.top/categories/Database/"/>
<category term="MySQL" scheme="http://jigw.top/tags/MySQL/"/>
<category term="Oracle" scheme="http://jigw.top/tags/Oracle/"/>
<category term="SQL" scheme="http://jigw.top/tags/SQL/"/>
</entry>
<entry>
<title>XML解析</title>
<link href="http://jigw.top/2019/04/26/XML%E8%A7%A3%E6%9E%90/"/>
<id>http://jigw.top/2019/04/26/XML解析/</id>
<published>2019-04-26T12:10:45.000Z</published>
<updated>2019-04-27T02:26:29.452Z</updated>
<content type="html"><![CDATA[<h1 id="解析"><a href="#解析" class="headerlink" title="解析"></a>解析</h1><hr><p>操作xml文档，将文档的数据读取到内存中。</p><h2 id="解析方式"><a href="#解析方式" class="headerlink" title="解析方式"></a>解析方式</h2><pre><code>DOM 将标记语言文档一次性加载进内存，在内存中形成一棵dom树优点：操作方便，可以对文档进行CRUD的所有操作缺点：占内存SAX 逐行读取，基于事件驱动优点：不占内存，相比DOM效率更高缺点：只能读取，不能增删改</code></pre><h2 id="解析器"><a href="#解析器" class="headerlink" title="解析器"></a>解析器</h2><p>常见解析器</p><pre><code>1. JAXP：sun公司提供的解析器，支持dom和sax两种思想2. DOM4J：一款非常优秀的解析器3. Jsoup：jsoup 是一款Java 的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据。4. PULL：Android操作系统内置的解析器，sax方式的。</code></pre><h3 id="DOM4J"><a href="#DOM4J" class="headerlink" title="DOM4J"></a>DOM4J</h3><p>本文中利用dom4j和xpath的支持进行解析，DOM4J中还提供了其他几种遍历节点的方法，例如枚举(Iterator)、递归、visitor模式等等。</p><p>范例</p><pre><code>1. 导包 dom4j-1.6.1.jar jaxen-1.1-beta-6.jar2. public class TestDemo01 { @Test public void method() throws DocumentException { //创建解析器 SAXReader saxReader = new SAXReader(); //解析xml Document document = saxReader.read(TestDemo01.class.getClassLoader().getResourceAsStream("student.xml")); //获取根标签 Element rootElement = document.getRootElement(); /*System.out.println(rootElement); //获取子标签 List elements = rootElement.elements(); //获取第一个 Object stu1 = elements.get(0); System.out.println(stu1); System.out.println("----------"); //student个数 List student = rootElement.elements("student"); int size = student.size(); System.out.println(size); System.out.println("----------"); //获取第一个学号 Element stu = rootElement.element("student"); String s1 = stu.attributeValue("number"); System.out.println(s1); System.out.println("----------"); //获取第一个年龄 Element age1 = stu.element("age"); String text = age1.getText(); System.out.println(text); // 即每一级便签和下一级标签用element方法获取第一个 } }3. 结合xpath Element element = (Element)rootElement.selectSingleNode("//student[@number='heima_0002']"); System.out.println(element);//xpath语法可通过xpath API文档查询</code></pre><h4 id="可能出现的问题"><a href="#可能出现的问题" class="headerlink" title="可能出现的问题"></a>可能出现的问题</h4><p>在idea中编程时，使用Schema约束会在写xml文件是自动出现 <strong>xmlns=”<a href="http://www.itcast.cn/xml"" target="_blank" rel="noopener">http://www.itcast.cn/xml"</a></strong>，使用这样的xml编码方式再结合xpath进行解析时，会发生找不到结果的问题</p><pre><code><students xmlns="http://www.itcast.cn/xml"> <student number="heima_0001"> <name>zhangsan</name> <age>24</age> <sex>male</sex> </student></students></code></pre><p>如获取</p><pre><code>Element element = (Element)rootElement.selectSingleNode("//student[@number='heima_0002']"); System.out.println(element);</code></pre><p>结果为<strong>null</strong></p><h3 id="Jsoup"><a href="#Jsoup" class="headerlink" title="Jsoup"></a>Jsoup</h3><p>步骤：</p><pre><code>1. 导入jar包 jsoup-1.11.2.jar JsoupXpath-0.3.2.jar2. 获取Document对象3. 获取对应的标签Element对象4. 获取数据</code></pre><p>代码：</p><pre><code>//2.1获取student.xml的path String path = JsoupDemo1.class.getClassLoader().getResource("student.xml").getPath(); //2.2解析xml文档，加载文档进内存，获取dom树--->Document Document document = Jsoup.parse(new File(path), "utf-8"); //3.获取元素对象 Element Elements elements = document.getElementsByTag("name"); System.out.println(elements.size()); //3.1获取第一个name的Element对象 Element element = elements.get(0); //3.2获取数据 String name = element.text(); System.out.println(name);</code></pre><p>对象的使用：</p><pre><code>1. Jsoup：工具类，可以解析html或xml文档，返回Document * parse：解析html或xml文档，返回Document * parse(File in, String charsetName)：解析xml或html文件的。 * parse(String html)：解析xml或html字符串 * parse(URL url, int timeoutMillis)：通过网络路径获取指定的html或xml的文档对象2. Document：文档对象。代表内存中的dom树 * 获取Element对象 * getElementById(String id)：根据id属性值获取唯一的element对象 * getElementsByTag(String tagName)：根据标签名称获取元素对象集合 * getElementsByAttribute(String key)：根据属性名称获取元素对象集合 * getElementsByAttributeValue(String key, String value)：根据对应的属性名和属性值获取元素对象集合3. Elements：元素Element对象的集合。可以当做 ArrayList<Element>来使用4. Element：元素对象 1. 获取子元素对象 * getElementById(String id)：根据id属性值获取唯一的element对象 * getElementsByTag(String tagName)：根据标签名称获取元素对象集合 * getElementsByAttribute(String key)：根据属性名称获取元素对象集合 * getElementsByAttributeValue(String key, String value)：根据对应的属性名和属性值获取元素对象集合 2. 获取属性值 * String attr(String key)：根据属性名称获取属性值 3. 获取文本内容 * String text():获取文本内容 * String html():获取标签体的所有内容(包括字标签的字符串内容)5. Node：节点对象 * 是Document和Element的父类</code></pre><p>快捷查询方式：</p><pre><code>1. selector:选择器 * 使用的方法：Elements select(String cssQuery) * 语法：参考Selector类中定义的语法2. XPath：XPath即为XML路径语言，它是一种用来确定XML（标准通用标记语言的子集）文档中某部分位置的语言 * 使用Jsoup的Xpath需要额外导入jar包。 * 查询w3cshool参考手册，使用xpath的语法完成查询 * 代码： //1.获取student.xml的path String path = JsoupDemo6.class.getClassLoader().getResource("student.xml").getPath(); //2.获取Document对象 Document document = Jsoup.parse(new File(path), "utf-8"); //3.根据document对象，创建JXDocument对象 JXDocument jxDocument = new JXDocument(document); //4.结合xpath语法查询 //4.1查询所有student标签 List<JXNode> jxNodes = jxDocument.selN("//student"); for (JXNode jxNode : jxNodes) { System.out.println(jxNode); } System.out.println("--------------------"); //4.2查询所有student标签下的name标签 List<JXNode> jxNodes2 = jxDocument.selN("//student/name"); for (JXNode jxNode : jxNodes2) { System.out.println(jxNode); } System.out.println("--------------------"); //4.3查询student标签下带有id属性的name标签 List<JXNode> jxNodes3 = jxDocument.selN("//student/name[@id]"); for (JXNode jxNode : jxNodes3) { System.out.println(jxNode); } System.out.println("--------------------"); //4.4查询student标签下带有id属性的name标签 并且id属性值为itcast List<JXNode> jxNodes4 = jxDocument.selN("//student/name[@id='itcast']"); for (JXNode jxNode : jxNodes4) { System.out.println(jxNode); }</code></pre>]]></content>
<summary type="html">
<h1 id="解析"><a href="#解析" class="headerlink" title="解析"></a>解析</h1><hr>
<p>操作xml文档，将文档的数据读取到内存中。</p>
<h2 id="解析方式"><a href="#解析方式" class="he
</summary>
<category term="JavaWeb" scheme="http://jigw.top/categories/JavaWeb/"/>
<category term="xml" scheme="http://jigw.top/tags/xml/"/>
<category term="xpath" scheme="http://jigw.top/tags/xpath/"/>
<category term="DOM4J" scheme="http://jigw.top/tags/DOM4J/"/>
<category term="Jsoup" scheme="http://jigw.top/tags/Jsoup/"/>
</entry>
<entry>
<title>更换电脑或重装系统时的博客配置</title>
<link href="http://jigw.top/2019/03/30/%E5%8D%9A%E5%AE%A2%E9%87%8D%E9%85%8D%E7%BD%AE/"/>
<id>http://jigw.top/2019/03/30/博客重配置/</id>
<published>2019-03-30T05:25:29.000Z</published>
<updated>2019-04-27T02:25:46.829Z</updated>
<content type="html"><![CDATA[<h1 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h1><p>首先感谢网络上的大佬们，查阅了一些人的博客总算解决了这一难题。废话少说，下面是简单的教程。</p><h2 id="准备"><a href="#准备" class="headerlink" title="准备"></a>准备</h2><ul><li>安装node.js</li><li>安装Git</li><li>备份你的本地博客目录的部分文件夹</li></ul><p><a href="http://jiguangwu.top/2018/01/10/hexo/#more" title="下载点此" target="_blank" rel="noopener">node.js和Git的安装包参考</a></p><p>拷贝文件夹如下</p><blockquote><p>_config.yml</p><p>theme/</p><p>source/</p><p>scaffolds/</p><p>package.json</p><p>.gitignore</p></blockquote><h2 id="配置你的Git"><a href="#配置你的Git" class="headerlink" title="配置你的Git"></a>配置你的Git</h2><p>桌面右键选择bash here,设置用户名称和邮件地址。</p><blockquote><p>1 $ git config –global user.name “username”</p><p>2 $ git config –global user.email “<a href="mailto:[email protected]" target="_blank" rel="noopener">[email protected]</a>“</p></blockquote><h2 id="配置SSH-Key"><a href="#配置SSH-Key" class="headerlink" title="配置SSH Key"></a>配置SSH Key</h2><p>输入</p><blockquote><p>$ ssh-keygen -t rsa -C “你的邮件地址”</p></blockquote><p>然后连续按三次回车，会生成id_rsa.pub文件，用记事本打开它，然后全部复制即可，待会要用。这个文件的地址：C:\Users\Administrator.ssh<br>打开你的GitHub主页，打开设置->Deploy keys->Add deploy key.<br>这里名称随便取，在下面粘贴内容保存即可。</p><p>我们回来测试下是否把SSH配置成功了。<br>继续在bash里输入</p><blockquote><p> $ ssh -T <a href="mailto:[email protected]" target="_blank" rel="noopener">[email protected]</a></p></blockquote><p>如果提示 Are you sure you want to continue connecting (yes/no)? ，输入yes，然后会看到 successfully authenticated,but github…..<br>看到这个意味着已成功！</p><h2 id="正式工作"><a href="#正式工作" class="headerlink" title="正式工作"></a>正式工作</h2><p>接下来时hexo和一些组件的安装，恭喜了很快了。</p><h1 id="安装hexo"><a href="#安装hexo" class="headerlink" title="安装hexo"></a>安装hexo</h1><p>我们打开cmd命令行，输入</p><blockquote><p>npm install -g hexo</p></blockquote><p>这里可能会很慢，所以推荐使用淘宝镜像。</p><blockquote><p>npm install -g cnpm –registry=<a href="https://registry.npm.taobao.org" target="_blank" rel="noopener">https://registry.npm.taobao.org</a></p></blockquote><p>验证是否安装成功使用：</p><blockquote><p>cnpm -v</p></blockquote><p>安装了淘宝镜像后，都使用cnpm指令：</p><blockquote><p>cnpm install -g hexo // 安装 hexo</p></blockquote><p>验证Hexo是否安装成功使用：</p><blockquote><p>hexo -v</p></blockquote><h1 id="安装一些组件"><a href="#安装一些组件" class="headerlink" title="安装一些组件"></a>安装一些组件</h1><blockquote><p> npm install hexo-deployer-git –save // 文章部署到 git 的模块（下面为选择安装）</p><p> npm install hexo-generator-feed –save // 建立 RSS 订阅</p><p> npm install hexo-generator-sitemap –save // 建立站点地图</p></blockquote><h1 id="部署到Github"><a href="#部署到Github" class="headerlink" title="部署到Github"></a>部署到Github</h1><p>输入指令</p><blockquote><p>hexo generate</p><p>hexo deploy</p></blockquote><p>没有报错就OK了。<br>这里讲讲hexo的一些快捷命令</p><blockquote><p>hexo g == hexo generate</p><p>hexo d == hexo deploy</p><p>hexo s == hexo server</p><p>hexo n == hexo new</p></blockquote><h1 id="测试"><a href="#测试" class="headerlink" title="测试"></a>测试</h1><p>尝试部署文章并使用以下指令更新部署</p><blockquote><p>hexo clean && hexo g && hexo d</p></blockquote><p>成功部署，恭喜你！博客重配置成功！</p><p>如果觉得有用，不如给个<a href="https://github.com/JiGuangwuu/JiGuangwuu.github.io" target="_blank" rel="noopener">Star Or Follow</a>，感谢。</p>]]></content>
<summary type="html">
<h1 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h1><p>首先感谢网络上的大佬们，查阅了一些人的博客总算解决了这一难题。废话少说，下面是简单的教程。</p>
<h2 id="准备"><a href=
</summary>
<category term="HexoAndBlog" scheme="http://jigw.top/categories/HexoAndBlog/"/>
<category term="hexo" scheme="http://jigw.top/tags/hexo/"/>
<category term="blog" scheme="http://jigw.top/tags/blog/"/>
</entry>
<entry>
<title>单例模式</title>
<link href="http://jigw.top/2019/03/26/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E4%B9%8B%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F/"/>
<id>http://jigw.top/2019/03/26/设计模式之单例模式/</id>
<published>2019-03-26T13:02:09.000Z</published>
<updated>2019-04-26T14:32:47.198Z</updated>
<content type="html"><![CDATA[<h1 id="理解"><a href="#理解" class="headerlink" title="理解"></a>理解</h1><p>设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。</p><h1 id="何为单例模式"><a href="#何为单例模式" class="headerlink" title="何为单例模式"></a>何为单例模式</h1><p>单例模式(Singleton)，又称单态模式或者单件模式。即保证一个类仅有一个实例，并提供一个访问它的全局访问点。<br>目的是即控制特定的类只产生一个对象，也允许在一定情况下灵活的改变对象的个数。</p><h1 id="如何实现"><a href="#如何实现" class="headerlink" title="如何实现"></a>如何实现</h1><p>先看一段代码</p><pre><code>public class Thing { private Thing(){ } private static Thing instance = new Thing(); //这段代码保证了Thread safe public static Thing getInstance(){ return instance; ｝｝ </code></pre><p>测试类</p><pre><code>public class TestDemo { public static void main(String[] args) { Thing t1 = Thing.getInstance(); Thing t2 = Thing.getInstance(); System.out.println(t1); System.out.println(t2); }}</code></pre><p>输出t1和t2的结果是一致的。<br>可以发现，我们将构造方法私有化了，这使得外面的类无法通过引用来创建对象；同时为了保证类的可用性，就必须提供一个自己的对象以及访问这个对象的静态方法。<br>因此，我们应该明白：<br>单例模式只有一个角色，而客户通过调用类的方法来创建对象。</p><p><img src="https://i.loli.net/2019/04/08/5cab563abef10.png" alt="单例原理"></p><h1 id="还有什么"><a href="#还有什么" class="headerlink" title="还有什么"></a>还有什么</h1><p>在上面的Thing类中我们“迫不及待”的创建了对象，但如果这个对象我们很长时间都没有使用就浪费了内存空间，因此称之为<strong>饿汉式</strong>。存在另一种写法，即<strong>懒汉式</strong>。<br>看这段代码</p><pre><code>private static Thing instance;public static Thing getInstance(){ if (instance==null){ instance = new Thing(); } return instance;}</code></pre><p>很明显，当程序真正需要这个对象的时候我们才开始创建。但是这在多线程情况下是有问题的，为了防止多线程环境中产生多个实例，我们做出改进，使用同步处理。</p><pre><code>private static Thing instance;public static Thing getInstance(){ //如果是对象还没创建的时候使用同步，如果对象已经创建完了，就不要同步了 ，这样效率就可以提高 if (instance==null){ synchronized (Thing.class){ if (instance==null){ //说明对象还没创建，所以里面使用了同步s instance = new Thing(); } } } return instance;}</code></pre><p>这里我们使用的是同步代码块，为什么不要同步方法呢？</p><pre><code> private static Thing instance;public synchronized static Thing getInstance(){ if (instance==null){ instance = new Thing(); } return instance;}</code></pre><p>通过使用同步方法，迫使每个线程在进入这个方法前要等候别的进程离开该方法。但同步会降低性能，并且这里只有第一次执行该方法时才会正在需要同步。之后每一次调用这个方法，同步都是浪费的。</p><h1 id="存在的问题"><a href="#存在的问题" class="headerlink" title="存在的问题"></a>存在的问题</h1><p>在学习单例模式时，通过这方面的书籍了解到以下问题</p><p><img src="https://i.loli.net/2019/04/08/5cab564492dd7.png" alt></p><p>如果觉得有用，不如给个<a href="https://github.com/JiGuangwuu/JiGuangwuu.github.io" target="_blank" rel="noopener">Star Or Follow</a>，感谢。</p>]]></content>
<summary type="html">
<h1 id="理解"><a href="#理解" class="headerlink" title="理解"></a>理解</h1><p>设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中
</summary>
<category term="设计模式" scheme="http://jigw.top/categories/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/"/>
<category term="interview" scheme="http://jigw.top/tags/interview/"/>
<category term="designPattern" scheme="http://jigw.top/tags/designPattern/"/>
</entry>
<entry>
<title>关于我的考研</title>
<link href="http://jigw.top/2019/02/20/190405/"/>
<id>http://jigw.top/2019/02/20/190405/</id>
<published>2019-02-20T01:28:09.000Z</published>
<updated>2019-05-02T06:03:32.852Z</updated>
<content type="html"><![CDATA[<p><img src="https://i.loli.net/2019/04/05/5ca771980ba09.png" alt="1"></p>]]></content>
<summary type="html">
<p><img src="https://i.loli.net/2019/04/05/5ca771980ba09.png" alt="1"></p>
</summary>
<category term="生活" scheme="http://jigw.top/categories/%E7%94%9F%E6%B4%BB/"/>
<category term="mood" scheme="http://jigw.top/tags/mood/"/>
</entry>
<entry>
<title>如何将本地项目部署到Github</title>
<link href="http://jigw.top/2019/02/05/%E9%83%A8%E7%BD%B2%E9%A1%B9%E7%9B%AE%E5%88%B0github/"/>
<id>http://jigw.top/2019/02/05/部署项目到github/</id>
<published>2019-02-05T01:28:09.000Z</published>
<updated>2019-04-26T01:32:54.247Z</updated>
<content type="html"><![CDATA[<h1 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h1><p>众所周知，GitHub是一个面向开源及私有软件项目的托管平台，那我们该如何将本地项目导入到Github上呢，这里，我写一个简单的教程，希望对你有所帮助。</p><h2 id="准备"><a href="#准备" class="headerlink" title="准备"></a>准备</h2><p>确定你的Git安装了，如果需要<a href="http://jiguangwu.top/2018/01/10/hexo/#more" title="下载参考" target="_blank" rel="noopener">点击此处</a></p><h2 id="开始"><a href="#开始" class="headerlink" title="开始"></a>开始</h2><p>首先在Github上新建一个repository，命名随意（以我为例，新建了一个Demo），勾选如图，create。</p><p><img src="https://i.loli.net/2019/03/26/5c9a1697490d0.png" alt="1"></p><p>然后，进入你的repository,打开settings，可以看到Github Pages的设置，在source中选择master branch。</p><p><img src="https://i.loli.net/2019/03/26/5c9a16d480146.png" alt="2"></p><p>最后，选择完会刷新页面，在去看Gith Pages时，会有显示一个网址，这就是你之后访问你项目页面的网址。<br><img src="https://i.loli.net/2019/03/26/5c9a16df8e603.png" alt="3"></p><h2 id="快了"><a href="#快了" class="headerlink" title="快了"></a>快了</h2><p>在一个盘里右键点击git bash here，打开bash命令行。如图，输入命令在D盘创建了文件夹Demo，第三个命令是克隆地址，格式为</p><blockquote><p><a href="https://github.com/用户名/项目名.git" target="_blank" rel="noopener">https://github.com/用户名/项目名.git</a></p></blockquote><p><img src="https://i.loli.net/2019/03/26/5c9a16eab9cd1.png" alt="4"></p><p>这时候你会发现你的D盘会多个Demo文件夹，打开它，进入根目录。</p><p>将自己的项目文件粘贴到这个根目录中。</p><p><img src="https://i.loli.net/2019/03/26/5c9a16eca4230.png" alt="5"></p><p><img src="https://i.loli.net/2019/03/26/5c9a16eebd4f2.png" alt="6"></p><p>执行如下命令，</p><p><img src="https://i.loli.net/2019/03/26/5c9a171336786.png" alt="7"></p><p>这里面注意，第一次操作需要你输入相关账号和密码，到时根据提示输入即可<br><img src="https://i.loli.net/2019/03/26/5c9a171e9432f.png" alt="8"></p><p><img src="https://i.loli.net/2019/03/26/5c9a1723ac514.png" alt="9"></p><h2 id="完成"><a href="#完成" class="headerlink" title="完成"></a>完成</h2><p>利用那个网址测试即可。</p><p>如果觉得有用，不如给个<a href="https://github.com/JiGuangwuu/JiGuangwuu.github.io" target="_blank" rel="noopener">starorfollow</a>，感谢。</p>]]></content>
<summary type="html">
<h1 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h1><p>众所周知，GitHub是一个面向开源及私有软件项目的托管平台，那我们该如何将本地项目导入到Github上呢，这里，我写一个简单的教程，希望对
</summary>
<category term="HexoAndBlog" scheme="http://jigw.top/categories/HexoAndBlog/"/>
<category term="blog" scheme="http://jigw.top/tags/blog/"/>
<category term="github" scheme="http://jigw.top/tags/github/"/>
</entry>
<entry>
<title>XML简介与约束</title>
<link href="http://jigw.top/2018/12/22/XML%E5%85%A5%E9%97%A8/"/>
<id>http://jigw.top/2018/12/22/XML入门/</id>
<published>2018-12-22T02:10:45.000Z</published>
<updated>2019-04-27T02:23:54.595Z</updated>
<content type="html"><![CDATA[<h1 id="简介"><a href="#简介" class="headerlink" title="简介"></a>简介</h1><hr><ul><li>XML是可扩展标记语言（Extensible Markup Language），可扩展即标签都是自定义的。</li><li><p>功能：存储数据 </p><pre><code>1. 配置文件2. 在网络中传输</code></pre></li><li><p>与HTML的区别</p><pre><code>1. xml标签都是自定义的，html标签是预定义。2. xml的语法严格（严格区分大小写），html语法松散3. xml是存储数据的，html是展示数据</code></pre></li><li><p>各个平台之间的数据传输类型，但现在已经被JSON替换了。XML可以存储简单、小量的数据。</p></li></ul><h1 id="基本语法"><a href="#基本语法" class="headerlink" title="基本语法"></a>基本语法</h1><hr><h2 id="写法"><a href="#写法" class="headerlink" title="写法"></a>写法</h2><p>注意：</p><ul><li>属性值必须使用引号(单双都可)引起来</li><li>标签名称区分大小写</li></ul><p>示例</p><pre><code> <?xml version='1.0' ?><users> <user id='1'> <name>zhangsan</name> <age>23</age> <gender>男</gender> </user> <user id='2'> <name>lisi</name> <age>25</age> <gender>男</gender> </user></users></code></pre><h2 id="组成部分"><a href="#组成部分" class="headerlink" title="组成部分"></a>组成部分</h2><pre><code>1. 文档声明 1. 格式：<?xml 属性列表 ?> 2. 属性列表： * version：版本号，必须的属性 * encoding：编码方式。告知解析引擎当前文档使用的字符集，默认值：ISO-8859-1 * standalone：是否独立 * 取值： * yes：不依赖其他文件 * no：依赖其他文件2. 指令(了解)：结合css的 * <?xml-stylesheet type="text/css" href="a.css" ?>3. 标签：标签名称自定义的 * 规则： * 名称可以包含字母、数字以及其他的字符 * 名称不能以数字或者标点符号开始 * 名称不能以字母 xml（或者 XML、Xml 等等）开始 * 名称不能包含空格 4. 属性： id属性值唯一5. 文本： * CDATA区：在该区域中的数据会被原样展示 * 格式： <![CDATA[ 数据 ]]></code></pre><h2 id="约束"><a href="#约束" class="headerlink" title="约束"></a>约束</h2><p>约束为规定XML文档的编写规则。</p><p>第一种约束 <strong>DTD</strong></p><pre><code>外部dtd：将约束的规则定义在外部的dtd文件中 * 本地：<!DOCTYPE 根标签名 SYSTEM "dtd文件的位置"> * 网络：<!DOCTYPE 根标签名 PUBLIC "dtd文件名字" "dtd文件的位置URL">内部dtd：写在内部</code></pre><p>外部范例</p><pre><code>//student.dtd文件<!ELEMENT students (student+) ><!ELEMENT student (name,age,sex)><!ELEMENT name (#PCDATA)><!ELEMENT age (#PCDATA)><!ELEMENT sex (#PCDATA)><!ATTLIST student number ID #REQUIRED>//student.xml文件<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE students SYSTEM "student.dtd"><students> <student number="s001"> <name>zhangsan</name> <age>abc</age> <sex>hehe</sex> </student> <student number="s002"> <name>lisi</name> <age>24</age> <sex>female</sex> </student></students></code></pre><p>第二种约束 <strong>Schema</strong></p><p>引入</p><pre><code> 1. 填写xml文档的根元素 2. 引入xsi前缀. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 3. 引入xsd文件命名空间. xsi:schemaLocation="http://www.itcast.cn/xml student.xsd" 4. 为每一个xsd约束声明一个前缀,作为标识 xmlns="http://www.itcast.cn/xml"<students xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.itcast.cn/xml" xsi:schemaLocation="http://www.itcast.cn/xml student.xsd"></code></pre><p>范例</p><p>student.xsd</p><pre><code><?xml version="1.0" ?><xsd:schema xmlns="http://www.itcast.cn/xml" xmlns:xsd="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.itcast.cn/xml" elementFormDefault="qualified"> <xsd:element name="students" type="studentsType"/> <xsd:complexType name="studentsType"> <xsd:sequence> <xsd:element name="student" type="studentType" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="studentType"> <xsd:sequence> <xsd:element name="name" type="xsd:string"/> <xsd:element name="age" type="ageType" /> <xsd:element name="sex" type="sexType" /> </xsd:sequence> <xsd:attribute name="number" type="numberType" use="required"/> </xsd:complexType> <xsd:simpleType name="sexType"> <xsd:restriction base="xsd:string"> <xsd:enumeration value="male"/> <xsd:enumeration value="female"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="ageType"> <xsd:restriction base="xsd:integer"> <xsd:minInclusive value="0"/> <xsd:maxInclusive value="256"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="numberType"> <xsd:restriction base="xsd:string"> <xsd:pattern value="heima_\d{4}"/> </xsd:restriction> </xsd:simpleType></xsd:schema></code></pre><p>student.xml</p><pre><code><?xml version="1.0" encoding="UTF-8" ?><students xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.itcast.cn/xml" xsi:schemaLocation="http://www.itcast.cn/xml student.xsd"> <student number="heima_0001"> <name>tom</name> <age>18</age> <sex>male</sex> </student></students></code></pre>]]></content>
<summary type="html">
<h1 id="简介"><a href="#简介" class="headerlink" title="简介"></a>简介</h1><hr>
<ul>
<li>XML是可扩展标记语言（Extensible Markup Language），可扩展即标签都是自定义的。</li>
</summary>
<category term="JavaWeb" scheme="http://jigw.top/categories/JavaWeb/"/>
<category term="xml" scheme="http://jigw.top/tags/xml/"/>
</entry>
<entry>
<title>Tomcat问题和项目部署</title>
<link href="http://jigw.top/2018/10/09/tomcat%E9%85%8D%E7%BD%AE/"/>
<id>http://jigw.top/2018/10/09/tomcat配置/</id>
<published>2018-10-09T09:19:45.000Z</published>
<updated>2019-04-28T15:51:52.826Z</updated>
<content type="html"><![CDATA[<h1 id="Tomcat可能出现的问题"><a href="#Tomcat可能出现的问题" class="headerlink" title="Tomcat可能出现的问题"></a>Tomcat可能出现的问题</h1><hr><pre><code>1. 黑窗口一闪而过： * 原因： 没有正确配置JAVA_HOME环境变量 * 解决方案：正确配置JAVA_HOME环境变量，并在path中添加%JAVA_HOME%\bin;2. 启动报错： 1. 暴力修改：找到占用的端口号，并且找到对应的进程，杀死该进程 * 命令行输入netstat -ano，查询到端口豪对应进程的PID 2. 温柔修改：修改自身的端口号 * conf/server.xml * <Connector port="8888" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8445" /> * 一般会将tomcat的默认端口号修改为80。80端口号是http协议的默认端口号。 * 好处：在访问时，就不用输入端口号</code></pre><h1 id="在Tomcat中部署项目的方式"><a href="#在Tomcat中部署项目的方式" class="headerlink" title="在Tomcat中部署项目的方式"></a>在Tomcat中部署项目的方式</h1><hr><pre><code>1. 直接将项目放到webapps目录下即可。 * /WebProject：项目的访问路径-->虚拟目录 * 简化部署：将项目打成一个war包，再将war包放置到webapps目录下。 * war包会自动解压缩2. 配置conf/server.xml文件 在<Host>标签体中配置 <Context docBase="D:\WebProject" path="/demo" /> * docBase:项目存放的路径 * path：虚拟目录3. 在conf\Catalina\localhost创建任意名称的xml文件。在文件中编写 <Context docBase="D:\WebProject" /> * 虚拟目录：xml文件的名称4. 在IDE中</code></pre>]]></content>
<summary type="html">
<h1 id="Tomcat可能出现的问题"><a href="#Tomcat可能出现的问题" class="headerlink" title="Tomcat可能出现的问题"></a>Tomcat可能出现的问题</h1><hr>
<pre><code>1. 黑窗口一闪而过：
</summary>
<category term="JavaWeb" scheme="http://jigw.top/categories/JavaWeb/"/>
<category term="Tomcat" scheme="http://jigw.top/tags/Tomcat/"/>
</entry>
<entry>
<title>eclipse的maven插件安装</title>
<link href="http://jigw.top/2018/09/07/eclipse%E6%8F%92%E4%BB%B6maven/"/>
<id>http://jigw.top/2018/09/07/eclipse插件maven/</id>
<published>2018-09-07T05:25:29.000Z</published>
<updated>2019-04-26T01:31:21.069Z</updated>
<content type="html"><![CDATA[<p>以eclipse kepler为例，<br>官网下载地址：<a href="http://www.eclipse.org/downloads/packages/release/Kepler/SR2" target="_blank" rel="noopener">http://www.eclipse.org/downloads/packages/release/Kepler/SR2</a></p><p>1.打开eclipse，help–install new software…</p><p>2.workwith里输入：<a href="http://download.eclipse.org/releases/kepler，输入完会有提示地址出现，点击回车静待.." target="_blank" rel="noopener">http://download.eclipse.org/releases/kepler，输入完会有提示地址出现，点击回车静待..</a>.</p><p>3.在filter框中输入maven便能定位要安装的插件<br><img src="https://i.imgur.com/vyBFPux.png" alt></p><p>4.选择“Collaboration”-“m2e - Maven Integration for Eclipse”，并点击next按钮进行安装</p><p>5.安装完成重启eclipse即可</p><p>6.配置你的maven</p><p>如果觉得有用，不如给个<a href="https://github.com/JiGuangwuu/JiGuangwuu.github.io" target="_blank" rel="noopener">Star Or Follow</a>，感谢。</p>]]></content>
<summary type="html">
<p>以eclipse kepler为例，<br>官网下载地址：<a href="http://www.eclipse.org/downloads/packages/release/Kepler/SR2" target="_blank" rel="noopener">http:/
</summary>
<category term="IDE" scheme="http://jigw.top/categories/IDE/"/>
<category term="maven" scheme="http://jigw.top/tags/maven/"/>
<category term="eclipse" scheme="http://jigw.top/tags/eclipse/"/>
</entry>
<entry>
<title>多态的一道面试题</title>
<link href="http://jigw.top/2018/08/11/%E5%A4%9A%E6%80%81%E7%9A%84%E4%B8%80%E9%81%93%E9%9D%A2%E8%AF%95%E9%A2%98/"/>
<id>http://jigw.top/2018/08/11/多态的一道面试题/</id>
<published>2018-08-11T06:55:29.000Z</published>
<updated>2019-04-26T14:27:24.654Z</updated>
<content type="html"><![CDATA[<h2 id="多态"><a href="#多态" class="headerlink" title="多态"></a>多态</h2><p>类A：</p><pre><code>class A { public String show(D obj){ return ("A and D"); } public String show(A obj){ return ("A and A"); } } </code></pre><p>类B：</p><pre><code>class B extends A{ public String show(B obj){ return ("B and B"); } public String show(A obj){ return ("B and A"); } } </code></pre><p>类C：</p><pre><code>class C extends B{}</code></pre><p>类D：</p><pre><code>class D extends B{}</code></pre><p>测试类：</p><pre><code>class DynamicTest{ public static void main(String[] args){ A a1 = new A(); A a2 = new B(); B b = new B(); C c = new C(); D d = new D(); System.out.println(a1.show(b)); System.out.println(a1.show(c)); System.out.println(a1.show(d)); System.out.println(a2.show(b)); System.out.println(a2.show(c)); System.out.println(a2.show(d)); System.out.println(b.show(b)); System.out.println(b.show(c)); System.out.println(b.show(d)); }}</code></pre><p>答案：</p><pre><code>System.out.println(a1.show(b)); AASystem.out.println(a1.show(c)); AASystem.out.println(a1.show(d)); ADSystem.out.println(a2.show(b)); BA 编译看左边，看右边可有重写 System.out.println(a2.show(c)); BA 同样，看可有重写！ System.out.println(a2.show(d)); AD 编译看左边，但没有重写System.out.println(b.show(b)); BB System.out.println(b.show(c)); BB 这里父类和爷爷类都可以，取最近的System.out.println(b.show(d)); AD B是A的子类 ，会把A的方法都继承</code></pre><p>如果觉得有用，不如给个<a href="https://github.com/JiGuangwuu/JiGuangwuu.github.io" target="_blank" rel="noopener">Star Or Follow</a>，感谢。</p>]]></content>
<summary type="html">
<h2 id="多态"><a href="#多态" class="headerlink" title="多态"></a>多态</h2><p>类A：</p>
<pre><code>class A {
public String show(D obj){
</summary>
<category term="Java" scheme="http://jigw.top/categories/Java/"/>
<category term="java" scheme="http://jigw.top/tags/java/"/>
<category term="interview" scheme="http://jigw.top/tags/interview/"/>
</entry>
<entry>
<title>构造、静态代码块面试题</title>
<link href="http://jigw.top/2018/06/05/%E6%9E%84%E9%80%A0%E9%9D%99%E6%80%81%E4%BB%A3%E7%A0%81%E5%9D%97/"/>
<id>http://jigw.top/2018/06/05/构造静态代码块/</id>
<published>2018-06-05T08:08:56.000Z</published>
<updated>2019-04-26T01:00:44.512Z</updated>
<content type="html"><![CDATA[<h1 id="复习"><a href="#复习" class="headerlink" title="复习"></a>复习</h1><p>构造代码块的执行时机：每次我们调用构造方法的时候都会先执行构造代码块中的代码，然后才去执行对应的构造方法中的代码。</p><p>静态代码块的执行时机：静态代码块其实就是在类加载的时候执行，一个类只会加载一次，所以静态代码块也最多只会执行一次。</p><pre><code>public class Test01 { { System.out.println("Test01的构造代码块"); } static { System.out.println("Test01的静态代码块"); } public Test01() { System.out.println("Test01的构造方法"); } public static void main(String[] args) { Student stu = new Student(); Student stu2 = new Student(); }}class Student { { System.out.println("Student的构造代码块"); } static { System.out.println("Student的静态代码块"); } public Student() { System.out.println("Student的构造方法"); }}</code></pre><p>答案：Test01的静态代码块 Student的静态代码块 Student的构造代码块<br>Student的构造方法 Student的构造代码块 Student的构造方法</p><p>如果觉得有用，不如给个<a href="https://github.com/JiGuangwuu/JiGuangwuu.github.io" target="_blank" rel="noopener">Star Or Follow</a>，感谢。</p>]]></content>
<summary type="html">
<h1 id="复习"><a href="#复习" class="headerlink" title="复习"></a>复习</h1><p>构造代码块的执行时机：每次我们调用构造方法的时候都会先执行构造代码块中的代码，然后才去执行对应的构造方法中的代码。</p>
<p>静态代码块
</summary>
<category term="Java" scheme="http://jigw.top/categories/Java/"/>
<category term="java" scheme="http://jigw.top/tags/java/"/>
<category term="interview" scheme="http://jigw.top/tags/interview/"/>
</entry>
<entry>
<title>冒泡、插入、选择排序</title>
<link href="http://jigw.top/2018/03/03/%E6%8E%92%E5%BA%8F1/"/>
<id>http://jigw.top/2018/03/03/排序1/</id>
<published>2018-03-03T08:34:33.000Z</published>
<updated>2019-04-26T01:01:42.847Z</updated>
<content type="html"><![CDATA[<h1 id="问题的引入"><a href="#问题的引入" class="headerlink" title="问题的引入"></a>问题的引入</h1><h2 id="从键盘输入10个整数并按从大到小的顺序排列，输出结果"><a href="#从键盘输入10个整数并按从大到小的顺序排列，输出结果" class="headerlink" title="从键盘输入10个整数并按从大到小的顺序排列，输出结果"></a><em>从键盘输入10个整数并按从大到小的顺序排列，输出结果</em></h2><h2 id="冒泡排序"><a href="#冒泡排序" class="headerlink" title="冒泡排序"></a>冒泡排序</h2><p>基本思想：比较所有相邻的两个元素，如果第一个数比第二个数大就交换它们两个。最后的数字应该最大得到升序排列。</p><p><img src="https://i.imgur.com/sTuENJp.png" alt></p><pre><code>package top.jgw;import java.util.Arrays;import java.util.Scanner;public class BubbleSort { public static void main(String[] args) { Scanner ra = new Scanner(System.in); System.out.print("请输入10个数："); int[] arr = new int[10]; for(int a=0;a<10;a++){ arr[a] = ra.nextInt(); } System.out.println("排序前的arr："+Arrays.toString(arr)); for(int i=arr.length-1;i>0;i--){ for(int j=1;j<=i;j++){ if(arr[j-1]>arr[j]){ int temp = arr[j-1]; arr[j-1] = arr[j]; arr[j] = temp; } } } System.out.println("排序后的arr ："+Arrays.toString(arr)); }}</code></pre><p>结论：冒泡排序是一种稳定的排序方法。 </p><ul><li>若文件初状为正序，则一趟起泡就可完成排序，排序码的比较次数为n-1，且没有记录移动，时间复杂度是O(n)</li><li>若文件初态为逆序，则需要n-1趟起泡，每趟进行n-i次排序码的比较，且每次比较都移动三次，比较和移动次数均达到最大值∶O(n2)</li><li>起泡排序平均时间复杂度为O(n2)</li></ul><h2 id="插入排序"><a href="#插入排序" class="headerlink" title="插入排序"></a>插入排序</h2><p>基本思想：每一步将一个待排序的记录，按其顺序码大小插入到前面已经排序的序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。</p><p><img src="https://i.imgur.com/rrF3K6J.png" alt></p><pre><code>package top.jgw;import java.util.Arrays;import java.util.Scanner;public class InsertionSort { public static void main(String[] args){ int i,j; int temp=0; Scanner ra=new Scanner(System.in); System.out.print("请输入10个数："); int arr[]=new int[10]; for(int a=0;a<10;a++){ arr[a]=ra.nextInt(); } System.out.println("排序前的arr: "+Arrays.toString(arr)); for(i=1;i<arr.length;i++){ temp=arr[i]; for(j=i-1;j>=0 && temp<arr[j];j--){ arr[j+1]=arr[j]; } arr[j+1]=temp; } System.out.println("排序后的arr："+Arrays.toString(arr)); }}</code></pre><p>结论：直接插入排序也是稳定的排序。<br>文件初态不同时，直接插入排序所耗费的时间有很大差异。若文件初态为正序，则每个待插入的记录只需要比较一次就能够找到合适的位置插入，故算法的时间复杂度为O(n)，这时最好的情况。若初态为反序，则第i个待插入记录需要比较i+1次才能找到合适位置插入，故时间复杂度为O(n2)，这时最坏的情况。</p><h2 id="选择排序"><a href="#选择排序" class="headerlink" title="选择排序"></a>选择排序</h2><p>基本思想：每一次排序都从待排序序列中选择一个最小元素放到已排好的序列的末端，重复此步骤可得到升序序列。</p><p><img src="https://i.imgur.com/Cmkm5Do.png" alt></p><pre><code>package top.jgw;import java.util.Arrays;import java.util.Scanner;public class SelectionSort {public static void main(String[] args){ Scanner ra=new Scanner(System.in); System.out.print("请输入10个数: "); int arr[]=new int[10]; for(int a=0;a<10;a++){ arr[a]=ra.nextInt(); } System.out.println("排序前的arr: "+Arrays.toString(arr)); int temp=0; for(int i=0;i<arr.length-1;i++){ for(int j=i+1;j<arr.length;j++){ if(arr[i]>arr[j]){ temp=arr[i]; arr[i]=arr[j]; arr[j]=temp; } } } System.out.println("排序后的arr: "+Arrays.toString(arr)); }}</code></pre><p>结论：简单选择排序是不稳定的排序，时间复杂度：T(n)=O(n2)。</p><p><em>日后补充…</em></p><p>如果觉得有用，不如给个<a href="https://github.com/JiGuangwuu/JiGuangwuu.github.io" target="_blank" rel="noopener">Star Or Follow</a>，感谢。</p>]]></content>
<summary type="html">
<h1 id="问题的引入"><a href="#问题的引入" class="headerlink" title="问题的引入"></a>问题的引入</h1><h2 id="从键盘输入10个整数并按从大到小的顺序排列，输出结果"><a href="#从键盘输入10个整数并按从大到
</summary>
<category term="数据结构与算法" scheme="http://jigw.top/categories/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/"/>
<category term="sort" scheme="http://jigw.top/tags/sort/"/>
</entry>
<entry>
<title>hexo＋next主题搭建GitHub blog干货教程</title>
<link href="http://jigw.top/2018/01/10/hexo/"/>
<id>http://jigw.top/2018/01/10/hexo/</id>
<published>2018-01-10T05:25:29.000Z</published>
<updated>2019-04-26T00:59:30.067Z</updated>
<content type="html"><![CDATA[<h1 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h1><p>本人开始并非使用next主题，这个大家可以去hexo官网<a href="https://hexo.io/themes/" target="_blank" rel="noopener">themes</a>处挑选自己喜欢的。<br>注意：点击主题预览图可以去预览下，点击主题名就可以去GitHub页面copy了。<br>但个人觉得next主题更好，bug少，拓展性强。好了，废话少说，进入正题。</p><h2 id="准备工作"><a href="#准备工作" class="headerlink" title="准备工作"></a>准备工作</h2><ul><li>注册github账号</li><li>安装node.js </li><li>链接：<a href="https://pan.baidu.com/s/1mji9SmO" target="_blank" rel="noopener">https://pan.baidu.com/s/1mji9SmO</a> 密码：fjw1</li><li>安装git </li><li>链接：<a href="https://pan.baidu.com/s/1dGUlqEH" target="_blank" rel="noopener">https://pan.baidu.com/s/1dGUlqEH</a> 密码：q9ws<br>我的电脑是Windows10，其他你根据我提供的百度云链接下载即可。安装git时全打勾。</li></ul><h2 id="创建仓库"><a href="#创建仓库" class="headerlink" title="创建仓库"></a>创建仓库</h2><p>新建一个 你的用户名.github.io的仓库，比如说你的GitHub用户名是abc,那么你新建仓库名叫abc.github.io,你的博客搭建好之后访问的网站也就是 <a href="https://abc.github.io了。" target="_blank" rel="noopener">https://abc.github.io了。</a></p><p><img src="https://i.loli.net/2019/03/26/5c9a1bdf14b7a.png" alt></p><p><img src="https://i.loli.net/2019/03/26/5c9a1be09c749.png" alt><br>那怎么删除仓库呢？？？<br>打开settings</p><p><img src="https://i.loli.net/2019/03/26/5c9a1be6b70f2.png" alt></p><p><img src="https://i.loli.net/2019/03/26/5c9a1be31d9a3.png" alt></p><h2 id="创建博客根目录"><a href="#创建博客根目录" class="headerlink" title="创建博客根目录"></a>创建博客根目录</h2><p>在一个磁盘里创建一个文件夹，比如我，在D盘创建了一个blog文件夹。</p><h1 id="正式工作"><a href="#正式工作" class="headerlink" title="正式工作"></a>正式工作</h1><h2 id="配置SSH-Key"><a href="#配置SSH-Key" class="headerlink" title="配置SSH Key"></a>配置SSH Key</h2><p>桌面右键打开git bash here,输入</p><blockquote><p> $ cd ~/. ssh // 检查本机已存在的 ssh 密钥</p></blockquote><p>再接着输入</p><blockquote><p>ssh-keygen -t rsa -C “你的邮件地址”</p></blockquote><p>然后连续按三次回车，会生成id_rsa.pub文件，用记事本打开它，然后全部复制即可，待会要用。这个文件的地址：C:\Users\Administrator.ssh<br>打开你的GitHub主页，打开设置->Deploy keys->Add deploy key.<br>这里名称随便取，在下面粘贴内容保存即可，有需要打勾就打勾。</p><p>我们回来测试下是否把SSH配置成功了。<br>继续在bash里输入</p><blockquote><p>$ ssh -T <a href="mailto:[email protected]" target="_blank" rel="noopener">[email protected]</a></p></blockquote><p>如果提示 Are you sure you want to continue connecting (yes/no)? ，输入yes，然后会看到 successfully authenticated,but github…..<br>看到这个意味着已成功！</p><h2 id="配置信息"><a href="#配置信息" class="headerlink" title="配置信息"></a>配置信息</h2><blockquote><p> $ git config –global user.name “xxx”// 你的github用户名，比如上面的abc<br>$ git config –global user.email “<a href="mailto:[email protected]" target="_blank" rel="noopener">[email protected]</a>“// 填写你的github注册邮箱</p></blockquote><h1 id="使用hexo"><a href="#使用hexo" class="headerlink" title="使用hexo"></a>使用hexo</h1><h2 id="安装hexo"><a href="#安装hexo" class="headerlink" title="安装hexo"></a>安装hexo</h2><p>我们打开cmd命令行，输入</p><blockquote><p> npm install -g hexo</p></blockquote><p>这里可能会很慢，所以推荐使用淘宝镜像。</p><blockquote><p>安装：<code>npm install -g cnpm --registry=https://registry.npm.taobao.org</code> </p><p>验证是否安装成功使用：<code>cnpm -v</code><br>这里使用使用： <code>cnpm install -g hexo安装</code>hexo</p><p>验证Hexo是否安装成功使用：<code>hexo -v</code> </p></blockquote><h2 id="初始化hexo"><a href="#初始化hexo" class="headerlink" title="初始化hexo"></a>初始化hexo</h2><p>打开我们之前创建的文件夹，比如我的blog，右击鼠标，打开git bash here,输入</p><blockquote><p>$ hexo init</p></blockquote><p>我们的文件夹会自动下载一些文件到这个blog目录里。</p><p>继续输入</p><blockquote><p>$ hexo g<br>$ hexo s</p></blockquote><p>hexo s是指启动服务，成功打开后会有提示，登录localhost:4000即可看到初始页面，到这里你的blog就基本搭建好了。</p><h2 id="新建文章"><a href="#新建文章" class="headerlink" title="新建文章"></a>新建文章</h2><p>在bash里输入</p><blockquote><p> $ hexo new post “文章名”</p></blockquote><p>然后去blog/source/_posts就可以看到</p><h2 id="上传到GitHub"><a href="#上传到GitHub" class="headerlink" title="上传到GitHub"></a>上传到GitHub</h2><p>配置_config.yml中的deploy部分，注意这里的_config.yml文件是blog根目录，并非themes里的同名文件。<br>配置如下(xxx为你的GitHub名)</p><blockquote><p> deploy:<br> type: git<br> repository: <a href="mailto:[email protected]" target="_blank" rel="noopener">[email protected]</a>:xxx/xxx.github.io.git<br> branch: master</p></blockquote><p>再次注意：关于_config.yml文件的配置，冒号后一定要加个空格，否则就无法部署了。</p><p>一切完成后在bash中继续输入</p><blockquote><p> npm install hexo-deployer-git –save #这里是安装插件，不然无法deploy</p></blockquote><p>然后输入以下就可以了</p><blockquote><p> hexo clean && hexo g && hexo d</p></blockquote><p>成功后会提示：Deploy done：git 证明成功啦。这是打开你的xxx.github.io就可以看到网页啦！</p><h2 id="主题设置"><a href="#主题设置" class="headerlink" title="主题设置"></a>主题设置</h2><p>打开<a href="http://theme-next.iissnan.com/getting-started.html" target="_blank" rel="noopener">next使用文档</a>有详细的教程。<br>主题教程以及拓展：<br><img src="https://i.imgur.com/lotL1do.png" alt></p><h1 id="绑定个性域名"><a href="#绑定个性域名" class="headerlink" title="绑定个性域名"></a>绑定个性域名</h1><h2 id="申请域名"><a href="#申请域名" class="headerlink" title="申请域名"></a>申请域名</h2><p>在阿里云或腾讯云申请域名。我是在阿里云申请的，实名认证很快，推荐。</p><h2 id="解析域名"><a href="#解析域名" class="headerlink" title="解析域名"></a>解析域名</h2><p>按我的内容来即可。<br><img src="https://i.loli.net/2019/03/26/5c9a1b95b0be7.png" alt></p><h2 id="部署域名"><a href="#部署域名" class="headerlink" title="部署域名"></a>部署域名</h2><p>在blog根目录的source文件夹中新建无后缀文件 CNAME。里面内容只写上你的域名即可，注意不需要www<br>按之前的顺序deploy即可</p><p>如果觉得有用，不如给个<a href="https://github.com/JiGuangwuu/JiGuangwuu.github.io" target="_blank" rel="noopener">Star Or Follow</a>，感谢。</p>]]></content>
<summary type="html">
<h1 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h1><p>本人开始并非使用next主题，这个大家可以去hexo官网<a href="https://hexo.io/themes/" target="
</summary>
<category term="HexoAndBlog" scheme="http://jigw.top/categories/HexoAndBlog/"/>
<category term="hexo" scheme="http://jigw.top/tags/hexo/"/>
<category term="blog" scheme="http://jigw.top/tags/blog/"/>
</entry>
<entry>
<title>出发永远是美好的一件事</title>
<link href="http://jigw.top/2018/01/07/%E5%87%BA%E5%8F%91/"/>
<id>http://jigw.top/2018/01/07/出发/</id>
<published>2018-01-07T12:18:31.000Z</published>
<updated>2019-04-26T01:33:09.508Z</updated>
<content type="html"><![CDATA[<p>去做就是啦。</p><p>总结了一七再去展望一八，哈哈我是真想做个技术流人才然后……<br>忙着结束手头上的事情，项目等等，想着去全身心投入到学习中，这是促进我去搭建自己的独立博客的初衷，去学习，去整理，去分享。<br>大学也浪了大半了，两次六级考试都几乎零准备，湖泊你说咋写来着？</p><p>要说新年计划的话，最近打算好好总结Java的知识，以及对基本框架，数据结构与算法的学习，对博客的维护与优化，还有考研的准备！</p><p>新年快乐！<br><img src="https://i.loli.net/2018/01/07/5a5211e581fdc.png" alt></p>]]></content>
<summary type="html">
<p>去做就是啦。</p>
<p>总结了一七再去展望一八，哈哈我是真想做个技术流人才然后……<br>忙着结束手头上的事情，项目等等，想着去全身心投入到学习中，这是促进我去搭建自己的独立博客的初衷，去学习，去整理，去分享。<br>大学也浪了大半了，两次六级考试都几乎零准备，湖泊你说
</summary>
<category term="生活" scheme="http://jigw.top/categories/%E7%94%9F%E6%B4%BB/"/>
<category term="mood" scheme="http://jigw.top/tags/mood/"/>
</entry>
</feed>